home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 2 / LSD and 17bit Compendium Deluxe - Volume II.iso / a / prog / misc / date.lha / Date / C / src / Date.c < prev    next >
Text File  |  1994-11-30  |  118KB  |  4,680 lines

  1. /* Date / Copyright 1994 by Kai Hofmann
  2. ******* Date/--history-- ****************************************************
  3. *
  4. *   NAME
  5. *    history -- This is the development history of the Date module
  6. *
  7. *   VERSION
  8. *    $VER: Date 33.089 (13.11.1994)
  9. *
  10. *   HISTORY
  11. *    16.01.1994 -    Procedures: JulianLeapYear(), GregorianLeapYear() &
  12. *            HeisLeapYear() initiated.
  13. *    22.01.1994 -    Procedures: JulianMonthDays(), GregorianMonthDays(),
  14. *            HeisMonthDays(), JulianYearDays(),
  15. *            GregorianYearDays(), HeisYearDays(), JulianDayDiff(),
  16. *            GregorianDayDiff(), HeisDayDiff(),
  17. *            JulianDaySmaller(), GregorianDaySmaller(),
  18. *            HeisDaySmaller(), JulianWeekday(),
  19. *            GregorianWeekday(), HeisWeekday(),
  20. *            JulianDaysBeforeWeekday(),
  21. *            GregorianDaysBeforeWeekday(),
  22. *            HeisDaysBeforeWeekday(), JulianDaysAfterWeekday(),
  23. *            GregorianDaysAfterWeekday(), HeisDaysAfterWeekday(),
  24. *            JulianDiffDate(), FreeDate() initiated.
  25. *            Types: Weekdays, Date, DatePtr initiated.
  26. *            Vars of Gregorian reform initiated
  27. *            (for changing to different countries)
  28. *    23.01.1994 -    Procedures: JulianDiffDate() finished,
  29. *            GregorianDiffDate(), HeisDiffDate(),
  30. *            JYearToScaliger(), GYearToScaliger(),
  31. *            HYearToScaliger(), ScaligerYearToJ(),
  32. *            ScaligerYearToG(), ScaligerYearToH(), JSYearToJD(),
  33. *            GSYearToJD(), HSYearToJD(), JDtoMJD(), MJDtoJD(),
  34. *            JulianToJD(), GregorianToJD(), HeisToJD(),
  35. *            TimeToJD(), JDToTime(), FreeTime() initiated.
  36. *            Types: Time, TimePtr initiated.
  37. *    28.01.1994 -    Procedures: GregorianMoonAge(), MoonMonthAge(),
  38. *            GregorianEaster() initiated.
  39. *    30.01.1994 -    Procedures: JulianDiffDate(), GregorianDiffDate(),
  40. *            HeisDiffDate(), JDToTime(), GregorianEaster() edited
  41. *            (changing return value from ptr to VAL variables).
  42. *            Procedures: FreeDate(), FreeTime() deleted.
  43. *            Types: Date, DatePtr, Time, TimePtr deleted (not
  44. *            longer needed, because of the procedure changes).
  45. *            Procedures: GregorianMoonAge(), GregorianEaster()
  46. *            changed    year parameter from CARDINAL to INTEGER
  47. *            (this is more consistent to the rest of the library).
  48. *            Bugs removed: GregorianWeekday(), HeisWeekday()
  49. *            (before removing, the weekday for leapyears was
  50. *            wrong)
  51. *            Procedure: GregorianEaster() finished.
  52. *    30.01.1994 -    Ported to Oberon-2
  53. *    31.01.1994 -    Compiled with Oberon-2 V3.11
  54. *    12.02.1994 -    Procedures: TimeZoneFactor(), LMT(), TimeToSec(),
  55. *            SecToTime() initiated.
  56. *            Version-String installed :)
  57. *    12.02.1994 -    Starting translation to SAS C 6.51
  58. *            Date.h translated
  59. *    13.02.1994 -    Continuation of C translation
  60. *    17.02.1994 -    New Oberon-2 Port, because yesterday Daniel Armor
  61. *            gives me a small hint about the SHORT command
  62. *            (I did not know about this!)
  63. *    17.02.1994 -    Small bug in Autodocs removed
  64. *            making this text as Date/--history-- autodoc
  65. *    17.02.1994 -    Continuation of C translation
  66. *    18.02.1994 -    Finished with C translation
  67. *    19.02.1994 -    C bugs removed (thanks to SAS for helping a C Lamer
  68. *            like me!), some optimizations done too.
  69. *    19.02.1994 -    Oberon-2 version compiled with V40.17 includes
  70. *    21.02.1994 -    Starting to write Modula-II testmodule
  71. *            Vars for the begining of Heis calculation initiated.
  72. *            Fixed small bugs in GregorianWeekday(),
  73. *            HeisWeekday(), TimeToSec(), SecToTime()
  74. *            Return-value of LMT() changed to LONGINT!
  75. *            Converting testmodule to Oberon-2
  76. *    22.02.1994 -    Converting testmodule to C
  77. *    23.02.1994 -    I noticed, that I forgot the 3 functions
  78. *            JulianWeek(), GregorianWeek(), HeisWeek()
  79. *    24.02.1994 -    Initiated the 3 forgotten functions
  80. *    26.02.1994 -    Initiating new GregorianEaster() with
  81. *            Gauß-algorithms    but ONLY for 1900-2099!
  82. *    27.02.1994 -    Bug fixed in JulianWeekday()
  83. *            Bugs fixed in JulianDayDiff(), GregorianDayDiff(),
  84. *            HeisDayDiff()
  85. *            JulianDayGreater(), GregorianDayGreater(),
  86. *            HeisDayGreater() Initiated.
  87. *    02.03.1994 -    Small bug fixed in HeisDayDiff()
  88. *            Bugs from 27.02. fixed in Modula-II and Oberon-2
  89. *            versions
  90. *            I found the way to extend GregorianEaster() !
  91. *            Little bug fixed in JulianWeek(), GregorianWeek(),
  92. *            HeisWeek() (~(M2) is not !(C))
  93. *    05.03.1994 -    Some internal bugs removed
  94. *            New internal procedures GregorianSB(),
  95. *            GregorianJHSB(), GregorianJHStartSB() !
  96. *            Extending GregorianEaster() :)
  97. *    11.03.1994 -    Things from 05.03. done in Modula-II and Oberon
  98. *    12.03.1994 -    If __SASC is defined autoinitialization instead of
  99. *            _DateInit() will be used!
  100. *    13.03.1994 -    After studying the SAS C Manual again I decided to
  101. *            check for __SASC_650 instead of __SASC because of
  102. *            the available priorities!
  103. *            Setting the priority of _DateInit() for
  104. *            autoinitialization to 600!
  105. *    15.03.1994 -    Making Date as library
  106. *    16.03.1994 -    Some work on the Autodocs was done,
  107. *            eliminating OldGregorianEaster() by comments
  108. *            (ANSI: STOP bad standards like that there are NO
  109. *             nested comments possible in C!!!).
  110. *    19.03.1994 -    Some work on the Autodocs was done in the M2 Code.
  111. *    20.03.1994 -    Some work on the Autodocs was done in the Oberon Code
  112. *    22.03.1994 -    In JDtoMJD(), MJDtoJD() an L was added to the
  113. *            constant.
  114. *            In GregorianWeekday(), HeisWeekday(),
  115. *            JulianDiffDate(), GregorianDiffDate(),
  116. *            HeisDiffDate(), JDToTime() I have inserted
  117. *            conversions (found with Borland C++ 4.0).
  118. *    24.03.1994 -    Making SunOS4.1.3, SunOS5.3(Solaris2.3) &
  119. *            RS6000 AIX3.2.? binaries with gcc.
  120. *            Eliminating nested commends by inserting a space
  121. *            between / and * (I hate this ANSI C standard
  122. *            feature for commends :(
  123. *    27.03.1994 -    Adding library register assignments to the autodocs.
  124. *    03.04.1994 -    Small fixes for the SAS C++ Compiler
  125. *            Small bug fixed in the M2 version of
  126. *            GregorianEaster()
  127. *    04.04.1994 -    Adding some 'static' keywords.
  128. *    10.04.1994 -    Changing from Shareware to Gift Ware ;-)
  129. *    02.08.1994 -    Small fixes in the Autodocs (thanks to Rita Reichl
  130. *            for correcting my bad english ;-)
  131. *    11.08.1994 -    Again small fixes in the Autodocs!
  132. *    13.11.1994 -    Small fix in JulianWeek(),GregorianWeek(),HeisWeek().
  133. *            Thanks to Jim Rickman for reporting the bug!
  134. *            Small changes in the Autodocs!
  135. *    30.11.1994 -    Fix the bug from 13.11. in M2 and Oberon code.
  136. *
  137. *****************************************************************************
  138. *
  139. *
  140. */
  141.  
  142. /*
  143. ******* Date/--background-- *************************************************
  144. *
  145. *   NAME
  146. *    Date -- This module was designed to help calc. calendar dates (V33)
  147. *
  148. *   FUNCTION
  149. *    I know about the date routines in the Amiga-OS(TM), but I decided
  150. *    not to use them because of their limited functionalities and of
  151. *    the portability of this module!
  152. *
  153. *   NOTES
  154. *    A tropical year is 365.2422 days! / 365d, 5h, 48min, 46sec
  155. *    A moon month is 29.53059 days! / 29d, 12h, 44min, 2.9 sec
  156. *    A moon phase is 7.38265 days!
  157. *
  158. *    (German) Books which helped me creating this library:
  159. *        Kleine Naturwissenschaftliche Bibliothek, Band 23
  160. *        Ewige Kalender
  161. *        A.W. Butkewitsch & M.S. Selikson
  162. *        5. Auflage
  163. *        Teubner, Leipzig 1974
  164. *        ISBN 3-322-00393-0
  165. *
  166. *        Tag und Woche, Monat und Jahr: eine Kulturgeschichte des
  167. *        Kalenders
  168. *        Rudolf Wendorff
  169. *        Westdeutscher, Opladen 1993
  170. *        ISBN 3-531-12417-X
  171. *
  172. *        Kalender und Chronologie: Bekanntes & Unbekanntes aus der
  173. *        Kalenderwissenschaft
  174. *        Heinz Zemanek
  175. *        4. Auflage
  176. *        Oldenbourg, München 1987
  177. *        ISBN 3-486-20447-5
  178. *
  179. *        Meyers Handbuch
  180. *        über das Weltall
  181. *        Karl Schaifers & Gerhard Traving
  182. *        5. Auflage
  183. *        Bibliographisches Institut Mannheim 1973
  184. *        ISBN 3-411-00940-3
  185. *
  186. *    (English) Books which helped me creating this library:
  187. *        Mathematical Astronomy with a Pocket Calculator
  188. *        Aubrey Jones Fras
  189. *        unknown(first) Edition
  190. *        David & Charles Newton Abbot, London 1978
  191. *        ISBN 0-7153-7675-6
  192. *
  193. *   COPYRIGHT
  194. *    This module is Copyright 1994 by Kai Hofmann - all rights reserved!
  195. *    For private use, Public Domain, Gift Ware, Freeware and Shareware
  196. *    you could use this module under following conditions:
  197. *    - You send me a little gift (money is very welcome :)
  198. *        For Bank Account see below - but *ONLY* send in DM
  199. *        to this Bank Account!!!
  200. *      Other nice gifts: all Amiga hardware, and I am searching for a
  201. *      good old 1541 (C64 floppy)
  202. *    - You include a notice in your product, that you use this library
  203. *      and that it is Copyright by Kai Hofmann!
  204. *    If you want to redistribute this library read the following points:
  205. *    - Redistribution warranty is given to:
  206. *        Fred Fish for his great Amiga-Software-Library
  207. *        The German SAAR AG PD-Library
  208. *        The German AMOK PD-Library
  209. *        All public accessible INTERNET servers and PHONE boxes!
  210. *        All others who do NOT take more than DM 5.- for one disk
  211. *        ALL others who do NOT take more than DM 50.- for one CD
  212. *    For commercial use send me DM 200.-
  213. *    But if you are Apple or Microsoft you have to send (20000.- US$)
  214. *
  215. *   DISCLAIMER
  216. *
  217. *      THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
  218. *   APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
  219. *   HOLDER AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
  220. *   OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
  221. *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  222. *   PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
  223. *   PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE
  224. *   COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  225. *
  226. *      IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
  227. *   WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY REDISTRIBUTE THE
  228. *   PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
  229. *   GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
  230. *   USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS
  231. *   OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR
  232. *   THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
  233. *   PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
  234. *   POSSIBILITY OF SUCH DAMAGES.
  235. *
  236. *   ADDITIONAL INFORMATIONS
  237. *    I have tried to make portable/useful and I hope bugfree software
  238. *    for eternity - but this seems to be impossible (sorry!) :)
  239. *    So I hope you will pay a fee for this.
  240. *
  241. *   AUTHOR
  242. *    Kai Hofmann
  243. *    Arberger Heerstraße 92
  244. *    28307 Bremen
  245. *    Germany
  246. *    EMail: i07m@zfn.uni-bremen.de
  247. *    (no phone - I hate it!)
  248. *
  249. *    Bank account : 1203 7503
  250. *    Account owner: Kai Hofmann
  251. *    Bank code    : 290 501 01
  252. *    Bank name    : Sparkasse in Bremen
  253. *
  254. *    THANX
  255. *    Thanx are going to the following people:
  256. *    Danial Armor        - For his hint about the Oberon-2 SHORT
  257. *                  command
  258. *    Heinz Zemanek        - For his great book
  259. *    Christian Schaefer    - For spending time on this lib with his
  260. *                  Borland C++ 4.0 compiler
  261. *    Rita Reichl        - For correcting my bad english ;-)
  262. *    Jim Rickman        - For reporting a bug
  263. *
  264. *****************************************************************************
  265. *
  266. *
  267. */
  268.  
  269.  #include "Date.h"
  270.  #include <stdlib.h> /* abs()   */
  271.  #include <math.h>   /* floor() */
  272.  
  273.  /* This is only for AMIGA */
  274.  #ifndef __SASC_650
  275.    #undef __MakeLib
  276.  #endif
  277.  #ifdef __MakeLib
  278.    #include <exec/libraries.h>
  279.  
  280.    void __regargs __chkabort(void);
  281.    void __regargs __chkabort(void)
  282.    {}
  283.  
  284.    void __regargs _CXBRK(void);
  285.    void __regargs _CXBRK(void)
  286.    {}
  287.  
  288.  #endif
  289.  
  290.  static unsigned short    BeforeGregorianDay, BeforeGregorianMonth,
  291.             AfterGregorianDay, AfterGregorianMonth,
  292.             StartHeisDay,StartHeisMonth;
  293.  static int        BeforeGregorianYear, AfterGregorianYear,
  294.             StartHeisYear;
  295.  
  296.  /* ----------------------------------------------------------------------- */
  297.  
  298.  #ifdef __MakeLib
  299.    bool __saveds __asm JulianLeapYear(register __d0 const int year)
  300.  #else
  301.    bool JulianLeapYear(const int year)
  302.  #endif
  303.  
  304. /*
  305. ******* Date/JulianLeapYear *************************************************
  306. *
  307. *   NAME
  308. *    JulianLeapYear -- Checks if a year is a leap year. (V33)
  309. *
  310. *   SYNOPSIS
  311. *    leapyear = JulianLeapYear(year);
  312. *       d0               d0
  313. *
  314. *    bool JulianLeapYear(const int year);
  315. *
  316. *   FUNCTION
  317. *    JulianLeapYear checks if a year is a leap year in the julian calendar
  318. *    For years after Chr. it checks if the year is devideable by 4.
  319. *    For years before Chr. a leap year must have a modulo 4 value of 1
  320. *
  321. *   INPUTS
  322. *    year - The year which should be checked (from -32768 to 32767)
  323. *        I think only values from -7 to 32767 are valid, because of
  324. *        the variant that was done on -8 by Augustus and other things!
  325. *
  326. *   RESULT
  327. *    leapyear - TRUE if the year is a leap year, otherwise false.
  328. *
  329. *   EXAMPLE
  330. *    ...
  331. *    if (JulianLeapYear(1994))
  332. *      printf("leap year!\n");
  333. *    else
  334. *      printf("no leap year!\n");
  335. *    ...
  336. *
  337. *   NOTES
  338. *    A year is 365.25 days long!
  339. *    Use this function only for values from -7 to 1582!
  340. *
  341. *   BUGS
  342. *    No known bugs.
  343. *
  344. *   SEE ALSO
  345. *    GregorianLeapYear(),HeisLeapYear()
  346. *
  347. *****************************************************************************
  348. *
  349. *
  350. */
  351.  
  352.   {if (year <= 0)
  353.      return((bool)(abs(year) % 4 == 1));
  354.    else
  355.      return((bool)(year % 4 == 0));
  356.   }
  357.  
  358.  
  359.  #ifdef __MakeLib
  360.    bool __saveds __asm GregorianLeapYear(register __d0 const int year)
  361.  #else
  362.    bool GregorianLeapYear(const int year)
  363.  #endif
  364.  
  365. /*
  366. ******* Date/GregorianLeapYear **********************************************
  367. *
  368. *   NAME
  369. *    GregorianLeapYear -- Checks if a year is a leap year. (V33)
  370. *
  371. *   SYNOPSIS
  372. *    leapyear = GregorianLeapYear(year);
  373. *       d0                  d0
  374. *
  375. *    bool GregorianLeapYear(const int year);
  376. *
  377. *   FUNCTION
  378. *    GregorianLeapYear checks if a year is a leap year.
  379. *    For years after 1582 all years devideable by 4 are leap years,
  380. *    without years devideable by 100, but years devideable by 400
  381. *    are leap years again!
  382. *    For years before 1582 see JulianLeapYear().
  383. *
  384. *   INPUTS
  385. *    year - The year which should be checked (from -32768 to 32767)
  386. *        I think only values from -7 to 3200 are valid, because of
  387. *        the variant that was done on -8 by Augustus and other things!
  388. *
  389. *   RESULT
  390. *    leapyear - TRUE if the year is a leap year, otherwise false.
  391. *
  392. *   EXAMPLE
  393. *    ...
  394. *    if (GregorianLeapYear(1994))
  395. *      printf("leap year!\n");
  396. *    else
  397. *      printf("no leap year!\n");
  398. *    ...
  399. *
  400. *   NOTES
  401. *    A year is 365.2425 days long!
  402. *    Use this function only for values from -7 to 3199!
  403. *
  404. *   BUGS
  405. *    No known bugs.
  406. *
  407. *   SEE ALSO
  408. *    JulianLeapYear(),HeisLeapYear()
  409. *
  410. *****************************************************************************
  411. *
  412. *
  413. */
  414.  
  415.   {if (year < BeforeGregorianYear)
  416.      {/* Year of the Gregorian reform */
  417.       return(JulianLeapYear(year));
  418.      }
  419.    else
  420.      {/* AfterGregorianYear reform */
  421.       return((bool)((year % 4 == 0) && ((year % 100 > 0) || (year % 400 == 0))));
  422.      }
  423.   }
  424.  
  425.  
  426.  #ifdef __MakeLib
  427.    bool __saveds __asm HeisLeapYear(register __d0 const int year)
  428.  #else
  429.    bool HeisLeapYear(const int year)
  430.  #endif
  431.  
  432. /*
  433. ******* Date/HeisLeapYear ***************************************************
  434. *
  435. *   NAME
  436. *    HeisLeapYear -- Checks if a year is a leap year. (V33)
  437. *
  438. *   SYNOPSIS
  439. *    leapyear = HeisLeapYear(year);
  440. *       d0             d0
  441. *
  442. *    bool HeisLeapYear(const int year);
  443. *
  444. *   FUNCTION
  445. *    HeisLeapYear checks if a year is a leap year.
  446. *    For years after 1582 see GregorianLeapYear(),
  447. *    The correction from N. Heis says, that all years devideable by
  448. *    3200 are no longer leap years!
  449. *    For years before 1582 see JulianLeapYear
  450. *
  451. *   INPUTS
  452. *    year - The year which should be checked (from -32768 to 32767)
  453. *        I think only values from -7 to 32767 are valid, because of
  454. *        the variant that was done on -8 by Augustus and other things!
  455. *
  456. *   RESULT
  457. *    leapyear - TRUE if the year is a leap year, otherwise false.
  458. *
  459. *   EXAMPLE
  460. *    ...
  461. *    if (HeisLeapYear(1994))
  462. *      printf("leap year!\n");
  463. *    else
  464. *      printf("no leap year!\n");
  465. *    ...
  466. *
  467. *   NOTES
  468. *    A year is now 365.2421875 days!
  469. *    Use this function only for values from -7 to 8000!
  470. *
  471. *   BUGS
  472. *    No known bugs.
  473. *
  474. *   SEE ALSO
  475. *    JulianLeapYear(),GregorianLeapYear()
  476. *
  477. *****************************************************************************
  478. *
  479. *
  480. */
  481.  
  482.   {if (year < BeforeGregorianYear)
  483.      {/* Year of the Gregorian reform */
  484.       return(JulianLeapYear(year));
  485.      }
  486.    else
  487.      {/* year >= AfterGregorianYear */
  488.       if (year % 3200 == 0)
  489.         {/* Correction from N. Heis */
  490.          return(false);
  491.         }
  492.       else
  493.         {/* (no leap year all 3200 years) */
  494.          return(GregorianLeapYear(year));
  495.         }
  496.      }
  497.   }
  498.  
  499.  /* ----------------------------------------------------------------------- */
  500.  
  501.  #ifdef __MakeLib
  502.    unsigned short __saveds __asm JulianMonthDays(register __d0 const unsigned short month, register __d1 const int year)
  503.  #else
  504.    unsigned short JulianMonthDays(const unsigned short month, const int year)
  505.  #endif
  506.  
  507. /*
  508. ******* Date/JulianMonthDays ************************************************
  509. *
  510. *   NAME
  511. *    JulianMonthDays -- Gives back the number of days of a month. (V33)
  512. *
  513. *   SYNOPSIS
  514. *    days = JulianMonthDays(month,year);
  515. *     d0            d0    d1
  516. *
  517. *    unsigned short JulianMonthDays(const unsigned short month,
  518. *        const int year);
  519. *
  520. *   FUNCTION
  521. *    JulianMonthDays gives you back the number of days a month in
  522. *    a specified year has.
  523. *
  524. *   INPUTS
  525. *    month - The month from which you want to get the number of days.
  526. *    year  - The year in which the month is.
  527. *
  528. *   RESULT
  529. *    days - The number of days the month uses, or 0 if you use
  530. *        a wrong month.
  531. *
  532. *   EXAMPLE
  533. *    ...
  534. *    days = JulianMonthDays(1,1994);
  535. *    printf("Days of January 1994 : %d\n",days);
  536. *    ...
  537. *
  538. *   NOTES
  539. *    It is better only to use this function for years from -7 to 09.1582!
  540. *
  541. *   BUGS
  542. *    No known bugs.
  543. *
  544. *   SEE ALSO
  545. *    JulianLeapYear(),GregorianMonthDays(),HeisMonthDays()
  546. *
  547. *****************************************************************************
  548. *
  549. *
  550. */
  551.  
  552.   {switch (month)
  553.      {case  1 :
  554.       case  3 :
  555.       case  5 :
  556.       case  7 :
  557.       case  8 :
  558.       case 10 :
  559.       case 12 : return(31);
  560.       case  4 :
  561.       case  6 :
  562.       case  9 :
  563.       case 11 : return(30);
  564.       case  2 : if (JulianLeapYear(year))
  565.                   return(29);
  566.                 else
  567.                   if (!JulianLeapYear(year))
  568.                     return(28);
  569.       default : return(0);
  570.      }
  571.   }
  572.  
  573.  
  574.  #ifdef __MakeLib
  575.    unsigned short __saveds __asm GregorianMonthDays(register __d0 const unsigned short month, register __d1 const int year)
  576.  #else
  577.    unsigned short GregorianMonthDays(const unsigned short month, const int year)
  578.  #endif
  579.  
  580. /*
  581. ******* Date/GregorianMonthDays *********************************************
  582. *
  583. *   NAME
  584. *    GregorianMonthDays -- Gives back the number of days of a month. (V33)
  585. *
  586. *   SYNOPSIS
  587. *    days = GregorianMonthDays(month,year);
  588. *     d0               d0    d1
  589. *
  590. *    unsigned short GregorianMonthDays(const unsigned short month,
  591. *        const int year);
  592. *
  593. *   FUNCTION
  594. *    GregorianMonthDays gives you back the number of days a month in
  595. *    a specified year has.
  596. *    For the year 1582 and the month 10 there are only 21 days,
  597. *    because of the Gregorian-reform 10 days are deleted from
  598. *    the month (for more - look out for books about this!)
  599. *
  600. *   INPUTS
  601. *    month - The month from which you want to get the number of days.
  602. *    year  - The year in which the month is.
  603. *
  604. *   RESULT
  605. *    days - The number of days the month uses, or 0 if you use
  606. *        a wrong month.
  607. *
  608. *   EXAMPLE
  609. *    ...
  610. *    days = GregorianMonthDays(1,1994);
  611. *    printf("Days of January 1994 : %d\n",days);
  612. *    ...
  613. *
  614. *   NOTES
  615. *    Use this function only for years from -7 to 3199!
  616. *
  617. *   BUGS
  618. *    none.
  619. *
  620. *   SEE ALSO
  621. *    GregorianLeapYear(),JulianMonthDays(),HeisMonthDays()
  622. *
  623. *****************************************************************************
  624. *
  625. *
  626. */
  627.  
  628.   {if ((year == AfterGregorianYear) && (month == AfterGregorianMonth))
  629.      {/* 10 days canceled by Gregor XIII
  630.                 in countries who chnaged later are more days */
  631.       return((unsigned short)(31-((AfterGregorianDay-BeforeGregorianDay)-1)));
  632.      }
  633.    else
  634.      if ((month == 2) && GregorianLeapYear(year))
  635.        return(29);
  636.      else
  637.        if ((month == 2) && (!GregorianLeapYear(year)))
  638.          return(28);
  639.        else
  640.          {/* use Julian function for other calcs. */
  641.           return(JulianMonthDays(month,year));
  642.          }
  643.   }
  644.  
  645.  
  646.  #ifdef __MakeLib
  647.    unsigned short __saveds __asm HeisMonthDays(register __d0 const unsigned short month, register __d1 const int year)
  648.  #else
  649.    unsigned short HeisMonthDays(const unsigned short month, const int year)
  650.  #endif
  651.  
  652. /*
  653. ******* Date/HeisMonthDays **************************************************
  654. *
  655. *   NAME
  656. *    HeisMonthDays -- Gives back the number of days of a month. (V33)
  657. *
  658. *   SYNOPSIS
  659. *    days = HeisMonthDays(month,year);
  660. *     d0              d0    d1
  661. *
  662. *    unsigned short HeisMonthDays(const unsigned short month,
  663. *        const int year);
  664. *
  665. *   FUNCTION
  666. *    HeisMonthDays gives you back the number of days a month in
  667. *    a specified year has.
  668. *    For the year 1582 and the month 10 there are only 21 days,
  669. *    because of the Gregorian-reform 10 days are deleted from
  670. *    the month (for more - look out for books about this!)
  671. *
  672. *   INPUTS
  673. *    month - The month from which you want to get the number of days.
  674. *    year  - The year in which the month is.
  675. *
  676. *   RESULT
  677. *    days - The number of days the month uses, or 0 if you use
  678. *        a wrong month.
  679. *
  680. *   EXAMPLE
  681. *    ...
  682. *    days = HeisMonthDays(1,1994);
  683. *    printf("Days of January 1994 : %d\n",days);
  684. *    ...
  685. *
  686. *   NOTES
  687. *    Use this function only for years from -7 to 8000!
  688. *
  689. *   BUGS
  690. *    See GregorianMonthDays!
  691. *
  692. *   SEE ALSO
  693. *    HeisLeapYear(),JulianMonthDays(),GregorianMonthDays()
  694. *
  695. *****************************************************************************
  696. *
  697. *
  698. */
  699.  
  700.   {if ((month == 2) && HeisLeapYear(year))
  701.      return(29);
  702.    else
  703.      if ((month == 2) && (!HeisLeapYear(year)))
  704.        return(28);
  705.      else
  706.        {/* use Gregorian function for other calcs */
  707.         return(GregorianMonthDays(month,year));
  708.        }
  709.   }
  710.  
  711.  /* ----------------------------------------------------------------------- */
  712.  
  713.  #ifdef __MakeLib
  714.    unsigned int __saveds __asm JulianYearDays(register __d0 const int year)
  715.  #else
  716.    unsigned int JulianYearDays(const int year)
  717.  #endif
  718.  
  719. /*
  720. ******* Date/JulianYearDays *************************************************
  721. *
  722. *   NAME
  723. *    JulianYearDays -- Gives back the number of days in a year. (V33)
  724. *
  725. *   SYNOPSIS
  726. *    days = JulianYearDays(year);
  727. *     d0               d0
  728. *
  729. *    unsigned int JulianYearDays(const int year);
  730. *
  731. *   FUNCTION
  732. *    JulianYearDays gives you back the number of days in
  733. *    a specified year.
  734. *
  735. *   INPUTS
  736. *    year  - The year in which to count the days.
  737. *
  738. *   RESULT
  739. *    days - The number of days the year uses.
  740. *
  741. *   EXAMPLE
  742. *    ...
  743. *    days = JulianYearDays(1994);
  744. *    printf("Days of 1994 : %d\n",days);
  745. *    ...
  746. *
  747. *   NOTES
  748. *    It is better only to use this function for years from -7 to 1581!
  749. *
  750. *   BUGS
  751. *    No known bugs.
  752. *
  753. *   SEE ALSO
  754. *    JulianMonthDays(),GregorianYearDays(),HeisYearDays()
  755. *
  756. *****************************************************************************
  757. *
  758. *
  759. */
  760.  
  761.  {unsigned short month;
  762.   unsigned int days;
  763.  
  764.   days = 0;
  765.   for (month=1; month<=12; month++)
  766.     {/* add the days of all 12 month */
  767.      days += JulianMonthDays(month,year);
  768.     }
  769.   return(days);
  770.  }
  771.  
  772.  
  773.  #ifdef __MakeLib
  774.    unsigned int __saveds __asm GregorianYearDays(register __d0 const int year)
  775.  #else
  776.    unsigned int GregorianYearDays(const int year)
  777.  #endif
  778.  
  779. /*
  780. ******* Date/GregorianYearDays **********************************************
  781. *
  782. *   NAME
  783. *    GregorianYearDays -- Gives back the number of days in a year. (V33)
  784. *
  785. *   SYNOPSIS
  786. *    days = GregorianYearDays(year);
  787. *     d0              d0
  788. *
  789. *    unsigned int GregorianYearDays(const int year);
  790. *
  791. *   FUNCTION
  792. *    GregorianYearDays gives you back the number of days in
  793. *    a specified year.
  794. *
  795. *   INPUTS
  796. *    year  - The year in which to count the days.
  797. *
  798. *   RESULT
  799. *    days - The number of days the year uses.
  800. *
  801. *   EXAMPLE
  802. *    ...
  803. *    days = GregorianYearDays(1994);
  804. *    printf("Days of 1994 : %d\n",days);
  805. *    ...
  806. *
  807. *   NOTES
  808. *    It is better only to use this function for years from -7 to 3199!
  809. *
  810. *   BUGS
  811. *    No known bugs.
  812. *
  813. *   SEE ALSO
  814. *    GregorianMonthDays(),JulianYearDays(),HeisYearDays()
  815. *
  816. *****************************************************************************
  817. *
  818. *
  819. */
  820.  
  821.  {unsigned short month;
  822.   unsigned int days;
  823.  
  824.   days = 0;
  825.   for (month=1; month<=12; month++)
  826.     {/* add the days of all 12 month */
  827.      days += GregorianMonthDays(month,year);
  828.     }
  829.   return(days);
  830.  }
  831.  
  832.  
  833.  #ifdef __MakeLib
  834.    unsigned int __saveds __asm HeisYearDays(register __d0 const int year)
  835.  #else
  836.    unsigned int HeisYearDays(const int year)
  837.  #endif
  838.  
  839. /*
  840. ******* Date/HeisYearDays ***************************************************
  841. *
  842. *   NAME
  843. *    HeisYearDays -- Gives back the number of days in a year. (V33)
  844. *
  845. *   SYNOPSIS
  846. *    days = HeisYearDays(year);
  847. *     d0             d0
  848. *
  849. *    unsigned int HeisYearDays(const int year);
  850. *
  851. *   FUNCTION
  852. *    HeisYearDays gives you back the number of days in
  853. *    a specified year.
  854. *
  855. *   INPUTS
  856. *    year  - The year in which to count the days.
  857. *
  858. *   RESULT
  859. *    days - The number of days the year uses.
  860. *
  861. *   EXAMPLE
  862. *    ...
  863. *    days = HeisYearDays(1994);
  864. *    printf("Days of 1994 : %d\n",days);
  865. *    ...
  866. *
  867. *   NOTES
  868. *    It is better only to use this function for years from -7 to 8000!
  869. *
  870. *   BUGS
  871. *    No known bugs.
  872. *
  873. *   SEE ALSO
  874. *    HeisMonthDays(),JulianYearDays(),GregorianYearDays()
  875. *
  876. *****************************************************************************
  877. *
  878. *
  879. */
  880.  
  881.  {unsigned short month;
  882.   unsigned int days;
  883.  
  884.   days = 0;
  885.   for (month=1; month<=12; month++)
  886.     {/* add the days of all 12 month */
  887.      days += HeisMonthDays(month,year);
  888.     }
  889.   return(days);
  890.  }
  891.  
  892.  /* ----------------------------------------------------------------------- */
  893.  
  894.  #ifdef __MakeLib
  895.    bool __saveds __asm JulianDaySmaller(register __d0 const unsigned short day1, register __d1 const unsigned short month1, register __d2 const int year1, register __d3 const unsigned short day2, register __d4 const unsigned short month2, register __d5 const int year2)
  896.  #else
  897.    bool JulianDaySmaller(const unsigned short day1, const unsigned short month1, const int year1, const unsigned short day2, const unsigned short month2, const int year2)
  898.  #endif
  899.  
  900. /*
  901. ******* Date/JulianDaySmaller ***********************************************
  902. *
  903. *   NAME
  904. *    JulianDaySmaller -- Checks if date1 is smaller than date2. (V33)
  905. *
  906. *   SYNOPSIS
  907. *    smaller = JulianDaySmaller(day1,month1,year1,day2,month2,year2);
  908. *      d0                d0    d1    d2    d3    d4    d5
  909. *
  910. *    bool JulianDaySmaller(const unsigned short day1,
  911. *        const unsigned short month1, const int year1,
  912. *        const unsigned short day2, const unsigned short month2,
  913. *        const int year2);
  914. *
  915. *   FUNCTION
  916. *    JulianDaySmaller test if date1 is smaller than date2.
  917. *
  918. *   INPUTS
  919. *    day1   - day of the first date
  920. *    month1 - month of the first date
  921. *    year1  - year of the first date
  922. *    day2   - day of the second date
  923. *    month2 - month of the second month
  924. *    year2  - year of the second date
  925. *
  926. *   RESULT
  927. *    smaller - This is TRUE is date1 < date2 otherwise it's FALSE.
  928. *
  929. *   EXAMPLE
  930. *    ...
  931. *    if (JulianDaySmaller(18,9,1970,22,1,1994))
  932. *      printf("<\n");
  933. *    else
  934. *      printf(">=\n");
  935. *    ...
  936. *
  937. *   NOTES
  938. *    It is better only to use this function for years from -7 to 1582!
  939. *
  940. *   BUGS
  941. *    No known bugs.
  942. *
  943. *   SEE ALSO
  944. *    GregorianDaySmaller(),HeisDaySmaller()
  945. *
  946. *****************************************************************************
  947. *
  948. *
  949. */
  950.  
  951.  {if (year1 == year2)
  952.     {if (month1 == month2)
  953.        return((bool)(day1 < day2));
  954.      else
  955.        return((bool)(month1 < month2));
  956.     }
  957.   else
  958.     return((bool)(year1 < year2));
  959.  }
  960.  
  961.  
  962.  #ifdef __MakeLib
  963.    bool __saveds __asm GregorianDaySmaller(register __d0 const unsigned short day1, register __d1 const unsigned short month1, register __d2 const int year1, register __d3 const unsigned short day2, register __d4 const unsigned short month2, register __d5 const int year2)
  964.  #else
  965.    bool GregorianDaySmaller(const unsigned short day1, const unsigned short month1, const int year1, const unsigned short day2, const unsigned short month2, const int year2)
  966.  #endif
  967.  
  968. /*
  969. ******* Date/GregorianDaySmaller ********************************************
  970. *
  971. *   NAME
  972. *    GregorianDaySmaller -- Checks if date1 is smaller than date2. (V33)
  973. *
  974. *   SYNOPSIS
  975. *    smaller = GregorianDaySmaller(day1,month1,year1,day2,month2,year2);
  976. *      d0                   d0    d1    d2    d3    d4    d5
  977. *
  978. *    bool GregorianDaySmaller(const unsigned short day1,
  979. *        const unsigned short month1, const int year1,
  980. *        const unsigned short day2, const unsigned short month2,
  981. *        const int year2);
  982. *
  983. *   FUNCTION
  984. *    GregorianDaySmaller test if date1 is smaller than date2.
  985. *
  986. *   INPUTS
  987. *    day1   - day of the first date
  988. *    month1 - month of the first date
  989. *    year1  - year of the first date
  990. *    day2   - day of the second date
  991. *    month2 - month of the second month
  992. *    year2  - year of the second date
  993. *
  994. *   RESULT
  995. *    smaller - This is TRUE is date1 < date2 otherwise it's FALSE.
  996. *
  997. *   EXAMPLE
  998. *    ...
  999. *    if (GregorianDaySmaller(18,9,1970,22,1,1994))
  1000. *      printf("<\n");
  1001. *    else
  1002. *      printf(">=\n");
  1003. *    ...
  1004. *
  1005. *   NOTES
  1006. *    It is better only to use this function for years from -7 to 3200!
  1007. *
  1008. *   BUGS
  1009. *    No known bugs.
  1010. *
  1011. *   SEE ALSO
  1012. *    JulianDaySmaller(),HeisDaySmaller()
  1013. *
  1014. *****************************************************************************
  1015. *
  1016. *
  1017. */
  1018.  
  1019.  {return(JulianDaySmaller(day1,month1,year1,day2,month2,year2));
  1020.  }
  1021.  
  1022.  
  1023.  #ifdef __MakeLib
  1024.    bool __saveds __asm HeisDaySmaller(register __d0 const unsigned short day1, register __d1 const unsigned short month1, register __d2 const int year1, register __d3 const unsigned short day2, register __d4 const unsigned short month2, register __d5 const int year2)
  1025.  #else
  1026.    bool HeisDaySmaller(const unsigned short day1, const unsigned short month1, const int year1, const unsigned short day2, const unsigned short month2, const int year2)
  1027.  #endif
  1028.  
  1029. /*
  1030. ******* Date/HeisDaySmaller *************************************************
  1031. *
  1032. *   NAME
  1033. *    HeisDaySmaller -- Checks if date1 is smaller than date2. (V33)
  1034. *
  1035. *   SYNOPSIS
  1036. *    smaller = HeisDaySmaller(day1,month1,year1,day2,month2,year2);
  1037. *      d0              d0    d1    d2    d3    d4    d5
  1038. *
  1039. *    bool HeisDaySmaller(const unsigned short day1,
  1040. *        const unsigned short month1, const int year1,
  1041. *        const unsigned short day2, const unsigned short month2,
  1042. *        const int year2);
  1043. *
  1044. *   FUNCTION
  1045. *    HeisDaySmaller test if date1 is smaller than date2.
  1046. *
  1047. *   INPUTS
  1048. *    day1   - day of the first date
  1049. *    month1 - month of the first date
  1050. *    year1  - year of the first date
  1051. *    day2   - day of the second date
  1052. *    month2 - month of the second month
  1053. *    year2  - year of the second date
  1054. *
  1055. *   RESULT
  1056. *    smaller - This is TRUE is date1 < date2 otherwise it's FALSE.
  1057. *
  1058. *   EXAMPLE
  1059. *    ...
  1060. *    if (HeisDaySmaller(18,9,1970,22,1,1994))
  1061. *      printf("<\n");
  1062. *    else
  1063. *      printf(">=\n");
  1064. *    ...
  1065. *
  1066. *   NOTES
  1067. *    It is better only to use this function for years from -7 to 8000!
  1068. *
  1069. *   BUGS
  1070. *    No known bugs.
  1071. *
  1072. *   SEE ALSO
  1073. *    JulianDaySmaller,GregorianDaySmaller()
  1074. *
  1075. *****************************************************************************
  1076. *
  1077. *
  1078. */
  1079.  
  1080.  {/* To avoid bugs if differences to JulianDaySmaller was found! */
  1081.   return(GregorianDaySmaller(day1,month1,year1,day2,month2,year2));
  1082.  }
  1083.  
  1084.  /* ----------------------------------------------------------------------- */
  1085.  
  1086.  #ifdef __MakeLib
  1087.    bool __saveds __asm JulianDayGreater(register __d0 const unsigned short day1, register __d1 const unsigned short month1, register __d2 const int year1, register __d3 const unsigned short day2, register __d4 const unsigned short month2, register __d5 const int year2)
  1088.  #else
  1089.    bool JulianDayGreater(const unsigned short day1, const unsigned short month1, const int year1, const unsigned short day2, const unsigned short month2, const int year2)
  1090.  #endif
  1091.  
  1092. /*
  1093. ******* Date/JulianDayGreater ***********************************************
  1094. *
  1095. *   NAME
  1096. *    JulianDayGreater -- Checks if date1 is greater than date2. (V33)
  1097. *
  1098. *   SYNOPSIS
  1099. *    greater = JulianDayGreater(day1,month1,year1,day2,month2,year2);
  1100. *      d0                d0    d1    d2    d3    d4    d5
  1101. *
  1102. *    bool JulianDayGreater(const unsigned short day1,
  1103. *        const unsigned short month1, const int year1,
  1104. *        const unsigned short day2, const unsigned short month2,
  1105. *        const int year2);
  1106. *
  1107. *   FUNCTION
  1108. *    JulianDayGreater test if date1 is greater than date2.
  1109. *
  1110. *   INPUTS
  1111. *    day1   - day of the first date
  1112. *    month1 - month of the first date
  1113. *    year1  - year of the first date
  1114. *    day2   - day of the second date
  1115. *    month2 - month of the second month
  1116. *    year2  - year of the second date
  1117. *
  1118. *   RESULT
  1119. *    greater - This is TRUE is date1 > date2 otherwise it's FALSE.
  1120. *
  1121. *   EXAMPLE
  1122. *    ...
  1123. *    if (JulianDayGreater(18,9,1970,22,1,1994))
  1124. *      printf(">\n");
  1125. *    else
  1126. *      printf("<=\n");
  1127. *    ...
  1128. *
  1129. *   NOTES
  1130. *    It is better only to use this function for years from -7 to 1582!
  1131. *
  1132. *   BUGS
  1133. *    No known bugs.
  1134. *
  1135. *   SEE ALSO
  1136. *    GregorianDayGreater(),HeisDayGreater()
  1137. *
  1138. *****************************************************************************
  1139. *
  1140. *
  1141. */
  1142.  
  1143.  {if (year1 == year2)
  1144.     {if (month1 == month2)
  1145.        return((bool)(day1 > day2));
  1146.      else
  1147.        return((bool)(month1 > month2));
  1148.     }
  1149.   else
  1150.     return((bool)(year1 > year2));
  1151.  }
  1152.  
  1153.  
  1154.  #ifdef __MakeLib
  1155.    bool __saveds __asm GregorianDayGreater(register __d0 const unsigned short day1, register __d1 const unsigned short month1, register __d2 const int year1, register __d3 const unsigned short day2, register __d4 const unsigned short month2, register __d5 const int year2)
  1156.  #else
  1157.    bool GregorianDayGreater(const unsigned short day1, const unsigned short month1, const int year1, const unsigned short day2, const unsigned short month2, const int year2)
  1158.  #endif
  1159.  
  1160. /*
  1161. ******* Date/GregorianDayGreater ********************************************
  1162. *
  1163. *   NAME
  1164. *    GregorianDayGreater -- Checks if date1 is greater than date2. (V33)
  1165. *
  1166. *   SYNOPSIS
  1167. *    greater = GregorianDayGreater(day1,month1,year1,day2,month2,year2);
  1168. *      d0                   d0    d1    d2    d3    d4    d5
  1169. *
  1170. *    bool GregorianDayGreater(const unsigned short day1,
  1171. *        const unsigned short month1, const int year1,
  1172. *        const unsigned short day2, const unsigned short month2,
  1173. *        const int year2);
  1174. *
  1175. *   FUNCTION
  1176. *    GregorianDayGreater test if date1 is greater than date2.
  1177. *
  1178. *   INPUTS
  1179. *    day1   - day of the first date
  1180. *    month1 - month of the first date
  1181. *    year1  - year of the first date
  1182. *    day2   - day of the second date
  1183. *    month2 - month of the second month
  1184. *    year2  - year of the second date
  1185. *
  1186. *   RESULT
  1187. *    greater - This is TRUE is date1 > date2 otherwise it's FALSE.
  1188. *
  1189. *   EXAMPLE
  1190. *    ...
  1191. *    if (GregorianDayGreater(18,9,1970,22,1,1994))
  1192. *      printf("<\n");
  1193. *    else
  1194. *      printf(">=\n");
  1195. *    ...
  1196. *
  1197. *   NOTES
  1198. *    It is better only to use this function for years from -7 to 3200!
  1199. *
  1200. *   BUGS
  1201. *    No known bugs.
  1202. *
  1203. *   SEE ALSO
  1204. *    JulianDayGreater(),HeisDayGreater()
  1205. *
  1206. *****************************************************************************
  1207. *
  1208. *
  1209. */
  1210.  
  1211.  {return(JulianDayGreater(day1,month1,year1,day2,month2,year2));
  1212.  }
  1213.  
  1214.  
  1215.  #ifdef __MakeLib
  1216.    bool __saveds __asm HeisDayGreater(register __d0 const unsigned short day1, register __d1 const unsigned short month1, register __d2 const int year1, register __d3 const unsigned short day2, register __d4 const unsigned short month2, register __d5 const int year2)
  1217.  #else
  1218.    bool HeisDayGreater(const unsigned short day1, const unsigned short month1, const int year1, const unsigned short day2, const unsigned short month2, const int year2)
  1219.  #endif
  1220.  
  1221. /*
  1222. ******* Date/HeisDayGreater *************************************************
  1223. *
  1224. *   NAME
  1225. *    HeisDayGreater -- Checks if date1 is greater than date2. (V33)
  1226. *
  1227. *   SYNOPSIS
  1228. *    greater = HeisDayGreater(day1,month1,year1,day2,month2,year2);
  1229. *      d0              d0    d1    d2    d3    d4    d5
  1230. *
  1231. *    bool HeisDayGreater(const unsigned short day1,
  1232. *        const unsigned short month1, const int year1,
  1233. *        const unsigned short day2, const unsigned short month2,
  1234. *        const int year2);
  1235. *
  1236. *   FUNCTION
  1237. *    HeisDayGreater test if date1 is greater than date2.
  1238. *
  1239. *   INPUTS
  1240. *    day1   - day of the first date
  1241. *    month1 - month of the first date
  1242. *    year1  - year of the first date
  1243. *    day2   - day of the second date
  1244. *    month2 - month of the second month
  1245. *    year2  - year of the second date
  1246. *
  1247. *   RESULT
  1248. *    greater - This is TRUE is date1 > date2 otherwise it's FALSE.
  1249. *
  1250. *   EXAMPLE
  1251. *    ...
  1252. *    if (HeisDayGreater(18,9,1970,22,1,1994))
  1253. *      printf(">\n");
  1254. *    else
  1255. *      printf("<=\n");
  1256. *    ...
  1257. *
  1258. *   NOTES
  1259. *    It is better only to use this function for years from -7 to 8000!
  1260. *
  1261. *   BUGS
  1262. *    No known bugs.
  1263. *
  1264. *   SEE ALSO
  1265. *    JulianDayGreater(),GregorianDayGreater()
  1266. *
  1267. *****************************************************************************
  1268. *
  1269. *
  1270. */
  1271.  
  1272.  {/* To avoid bugs if differences to JulianDaySmaller was found! */
  1273.   return(GregorianDayGreater(day1,month1,year1,day2,month2,year2));
  1274.  }
  1275.  
  1276.  /* ----------------------------------------------------------------------- */
  1277.  
  1278.  #ifdef __MakeLib
  1279.    long __saveds __asm JulianDayDiff(register __d0 const unsigned short day1, register __d1 unsigned short month1, register __d2 int year1, register __d3 const unsigned short day2, register __d4 unsigned short month2, register __d5 int year2)
  1280.  #else
  1281.    long JulianDayDiff(const unsigned short day1, unsigned short month1, int year1, const unsigned short day2, unsigned short month2, int year2)
  1282.  #endif
  1283.  
  1284. /*
  1285. ******* Date/JulianDayDiff **************************************************
  1286. *
  1287. *   NAME
  1288. *    JulianDayDiff -- Calculates the days between 2 dates. (V33)
  1289. *
  1290. *   SYNOPSIS
  1291. *    days = JulianDayDiff(day1,month1,year1,day2,month2,year2);
  1292. *     d0              d0    d1    d2    d3    d4    d5
  1293. *
  1294. *    long JulianDayDiff(const unsigned short day1, unsigned short month1,
  1295. *        int year1, const unsigned short day2, unsigned short month2,
  1296. *        int year2);
  1297. *
  1298. *   FUNCTION
  1299. *    JulianDayDiff gives you back the number of days between
  1300. *    two specified dates.
  1301. *
  1302. *   INPUTS
  1303. *    day1   - day of the first date
  1304. *    month1 - month of the first date
  1305. *    year1  - year of the first date
  1306. *    day2   - day of the second date
  1307. *    month2 - month of the second month
  1308. *    year2  - year of the second date
  1309. *
  1310. *   RESULT
  1311. *    days - The number of days between the two dates
  1312. *        (positive if date1 <= date2).
  1313. *
  1314. *   EXAMPLE
  1315. *    ...
  1316. *    days = JulianDayDiff(18,9,1970,22,1,1994);
  1317. *    printf("Age of Kai Hofmann in days : %d\n",days);
  1318. *    ...
  1319. *
  1320. *   NOTES
  1321. *    It is better only to use this function for years from -7 to 1582!
  1322. *
  1323. *   BUGS
  1324. *    No known bugs.
  1325. *
  1326. *   SEE ALSO
  1327. *    JulianLeapYear(),JulianMonthDays(),JulianYearDays(),
  1328. *    GregorianDayDiff(),HeisDayDiff()
  1329. *
  1330. *****************************************************************************
  1331. *
  1332. *
  1333. */
  1334.  
  1335.  {unsigned long t1,t2;
  1336.  
  1337.   t1 = day1; /* set days left in the actual month */
  1338.   t2 = day2;
  1339.  
  1340.   while (month1 > 1)
  1341.     {/* calc days left by the gone month of the year1 */
  1342.      month1--;
  1343.      t1 += JulianMonthDays(month1,year1);
  1344.     }
  1345.  
  1346.   while (month2 > 1)
  1347.     {/* calc days left by the gone month of the year2 */
  1348.      month2--;
  1349.      t2 += JulianMonthDays(month2,year2);
  1350.     }
  1351.  
  1352.   while (year1 > year2)
  1353.     {/* calc days of diff years */
  1354.      year1--;
  1355.      t1 += JulianYearDays(year1);
  1356.     }
  1357.  
  1358.   while (year1 < year2)
  1359.     {/* calc days of diff years */
  1360.      year2--;
  1361.      t2 += JulianYearDays(year2);
  1362.     }
  1363.  
  1364.   return((long)t2-(long)t1);
  1365.  }
  1366.  
  1367.  
  1368.  #ifdef __MakeLib
  1369.    long __saveds __asm GregorianDayDiff(register __d0 const unsigned short day1, register __d1 unsigned short month1, register __d2 int year1, register __d3 const unsigned short day2, register __d4 unsigned short month2, register __d5 int year2)
  1370.  #else
  1371.    long GregorianDayDiff(const unsigned short day1, unsigned short month1, int year1, const unsigned short day2, unsigned short month2, int year2)
  1372.  #endif
  1373.  
  1374. /*
  1375. ******* Date/GregorianDayDiff ***********************************************
  1376. *
  1377. *   NAME
  1378. *    GregorianDayDiff -- Calculates the days between 2 dates. (V33)
  1379. *
  1380. *   SYNOPSIS
  1381. *    days = GregorianDayDiff(day1,month1,year1,day2,month2,year2);
  1382. *     d0                 d0    d1    d2    d3    d4    d5
  1383. *
  1384. *    long GregorianDayDiff(const unsigned short day1,
  1385. *        unsigned short month1, int year1, const unsigned short day2,
  1386. *        unsigned short month2, int year2);
  1387. *
  1388. *   FUNCTION
  1389. *    GregorianDayDiff gives you back the number of days between
  1390. *    two specified dates.
  1391. *
  1392. *   INPUTS
  1393. *    day1   - day of the first date
  1394. *    month1 - month of the first date
  1395. *    year1  - year of the first date
  1396. *    day2   - day of the second date
  1397. *    month2 - month of the second month
  1398. *    year2  - year of the second date
  1399. *
  1400. *   RESULT
  1401. *    days - The number of days between the two dates
  1402. *        (positive if date1 <= date2).
  1403. *
  1404. *   EXAMPLE
  1405. *    ...
  1406. *    days = GregorianDayDiff(18,9,1970,22,1,1994);
  1407. *    printf("Age of Kai Hofmann in days : %d\n",days);
  1408. *    ...
  1409. *
  1410. *   NOTES
  1411. *    It is better only to use this function for years from -7 to 02.3200!
  1412. *
  1413. *   BUGS
  1414. *    If you use one of the dates 5.10.1582 to 14.10.1582 you will get a
  1415. *    wrong output because these days don't exist!
  1416. *
  1417. *   SEE ALSO
  1418. *    GregorianLeapYear(),GregorianMonthDays(),GregorianYearDays(),
  1419. *    JulianDayDiff(),HeisDayDiff()
  1420. *
  1421. *****************************************************************************
  1422. *
  1423. *
  1424. */
  1425.  
  1426.  {long t1,t2;
  1427.  
  1428.   t1 = day1; /* set days left in the actual month */
  1429.   t2 = day2;
  1430.  
  1431.   if ((year1 == 1582) && (month1 == 10))
  1432.    {if ((day1 < 5) && GregorianDaySmaller(day1,month1,year1,day2,month2,year2) && GregorianDaySmaller(day2,month2,year2,1,11,1582) && GregorianDayGreater(day2,month2,year2,14,10,1582))
  1433.       t2 -= 10;
  1434.     if (day1 > 14)
  1435.      {if (GregorianDaySmaller(day1,month1,year1,day2,month2,year2) && GregorianDayGreater(day2,month2,year2,31,10,1582))
  1436.         t2 += 10;
  1437.       if (GregorianDayGreater(day1,month1,year1,day2,month2,year2) && GregorianDaySmaller(day2,month2,year2,5,10,1582))
  1438.         t1 -= 10;
  1439.      }
  1440.    }
  1441.   if ((year2 == 1582) && (month2 == 10) && (day2 > 14))
  1442.    {if (GregorianDaySmaller(day2,month2,year2,day1,month1,year1) && GregorianDayGreater(day1,month1,year1,31,10,1582))
  1443.       t1 += 10;
  1444.     if (GregorianDayGreater(day2,month2,year2,day1,month1,year1) && GregorianDaySmaller(day1,month1,year1,1,10,1582))
  1445.       t2 -= 10;
  1446.    }
  1447.  
  1448.   while (month1 > 1)
  1449.     {/* calc days left by the gone month of the year1 */
  1450.      month1--;
  1451.      t1 += GregorianMonthDays(month1,year1);
  1452.     }
  1453.  
  1454.   while (month2 > 1)
  1455.     {/* calc days left by the gone month of the year2 */
  1456.      month2--;
  1457.      t2 += GregorianMonthDays(month2,year2);
  1458.     }
  1459.  
  1460.   while (year1 > year2)
  1461.     {/* calc days of diff years */
  1462.      year1--;
  1463.      t1 += GregorianYearDays(year1);
  1464.     }
  1465.  
  1466.   while (year1 < year2)
  1467.     {/* calc days of diff years */
  1468.      year2--;
  1469.      t2 += GregorianYearDays(year2);
  1470.     }
  1471.  
  1472.   return(t2-t1);
  1473.  }
  1474.  
  1475.  
  1476.  #ifdef __MakeLib
  1477.    long __saveds __asm HeisDayDiff(register __d0 const unsigned short day1, register __d1 unsigned short month1, register __d2 int year1, register __d3 const unsigned short day2, register __d4 unsigned short month2, register __d5 int year2)
  1478.  #else
  1479.    long HeisDayDiff(const unsigned short day1, unsigned short month1, int year1, const unsigned short day2, unsigned short month2, int year2)
  1480.  #endif
  1481.  
  1482. /*
  1483. ******* Date/HeisDayDiff ****************************************************
  1484. *
  1485. *   NAME
  1486. *    HeisDayDiff -- Calculates the days between 2 dates. (V33)
  1487. *
  1488. *   SYNOPSIS
  1489. *    days = HeisDayDiff(day1,month1,year1,day2,month2,year2);
  1490. *     d0            d0    d1    d2    d3    d4    d5
  1491. *
  1492. *    long HeisDayDiff(const unsigned short day1, unsigned short month1,
  1493. *        int year1, const unsigned short day2, unsigned short month2,
  1494. *        int year2);
  1495. *
  1496. *   FUNCTION
  1497. *    HeisDayDiff gives you back the number of days between
  1498. *    two specified dates.
  1499. *
  1500. *   INPUTS
  1501. *    day1   - day of the first date
  1502. *    month1 - month of the first date
  1503. *    year1  - year of the first date
  1504. *    day2   - day of the second date
  1505. *    month2 - month of the second month
  1506. *    year2  - year of the second date
  1507. *
  1508. *   RESULT
  1509. *    days - The number of days between the two dates
  1510. *        (positive if date1 <= date2).
  1511. *
  1512. *   EXAMPLE
  1513. *    ...
  1514. *    days = HeisDayDiff(18,9,1970,22,1,1994);
  1515. *    printf("Age of Kai Hofmann in days : %d\n",days);
  1516. *    ...
  1517. *
  1518. *   NOTES
  1519. *    It is better only to use this function for years from -7 to 8000!
  1520. *
  1521. *   BUGS
  1522. *    If you use on of the dates 5.10.1582 to 14.10.1582 you will get
  1523. *    wrong output because these days don't exist!
  1524. *
  1525. *   SEE ALSO
  1526. *    HeisLeapYear(),HeisMonthDays(),HeisYearDays(),
  1527. *    JulianDayDiff(),GregorianDayDiff()
  1528. *
  1529. *****************************************************************************
  1530. *
  1531. *
  1532. */
  1533.  
  1534.  {long t1,t2;
  1535.  
  1536.   t1 = day1; /* set days left in the actual month */
  1537.   t2 = day2;
  1538.  
  1539.   if ((year1 == 1582) && (month1 == 10))
  1540.    {if ((day1 < 5) && HeisDaySmaller(day1,month1,year1,day2,month2,year2) && HeisDaySmaller(day2,month2,year2,1,11,1582) && HeisDayGreater(day2,month2,year2,14,10,1582))
  1541.       t2 -= 10;
  1542.     if (day1 > 14)
  1543.      {if (HeisDaySmaller(day1,month1,year1,day2,month2,year2) && HeisDayGreater(day2,month2,year2,31,10,1582))
  1544.         t2 += 10;
  1545.       if (HeisDayGreater(day1,month1,year1,day2,month2,year2) && HeisDaySmaller(day2,month2,year2,5,10,1582))
  1546.         t1 -= 10;
  1547.      }
  1548.    }
  1549.   if ((year2 == 1582) && (month2 == 10) && (day2 > 14))
  1550.    {if (HeisDaySmaller(day2,month2,year2,day1,month1,year1) && HeisDayGreater(day1,month1,year1,31,10,1582))
  1551.       t1 += 10;
  1552.     if (HeisDayGreater(day2,month2,year2,day1,month1,year1) && HeisDaySmaller(day1,month1,year1,1,10,1582))
  1553.       t2 -= 10;
  1554.    }
  1555.  
  1556.   while (month1 > 1)
  1557.     {/* calc days left by the gone month of the year1 */
  1558.      month1--;
  1559.      t1 += HeisMonthDays(month1,year1);
  1560.     }
  1561.  
  1562.   while (month2 > 1)
  1563.     {/* calc days left by the gone month of the year2 */
  1564.      month2--;
  1565.      t2 += HeisMonthDays(month2,year2);
  1566.     }
  1567.  
  1568.   while (year1 > year2)
  1569.     {/* calc days of diff years */
  1570.      year1--;
  1571.      t1 += HeisYearDays(year1);
  1572.     }
  1573.  
  1574.   while (year1 < year2)
  1575.     {/* calc days of diff years */
  1576.      year2--;
  1577.      t2 += HeisYearDays(year2);
  1578.     }
  1579.  
  1580.   return(t2-t1);
  1581.  }
  1582.  
  1583.  /* ----------------------------------------------------------------------- */
  1584.  
  1585.  #ifdef __MakeLib
  1586.    Weekdays __saveds __asm JulianWeekday(register __d0 const unsigned short day, register __d1 unsigned short month, register __d2 int year)
  1587.  #else
  1588.    Weekdays JulianWeekday(const unsigned short day, unsigned short month, int year)
  1589.  #endif
  1590.  
  1591. /*
  1592. ******* Date/JulianWeekday **************************************************
  1593. *
  1594. *   NAME
  1595. *    JulianWeekday -- Gets the weekday of a specified date. (V33)
  1596. *
  1597. *   SYNOPSIS
  1598. *    weekday = JulianWeekday(day,month,year);
  1599. *      d0             d0   d1   d2
  1600. *
  1601. *    Weekdays JulianWeekday(const unsigned short day,
  1602. *        unsigned short month, int year);
  1603. *
  1604. *   FUNCTION
  1605. *    JulianWeekday gets the weekday for a specified date.
  1606. *
  1607. *   INPUTS
  1608. *    day   - day of the date
  1609. *    month - month of the date
  1610. *    year  - year of the date
  1611. *
  1612. *   RESULT
  1613. *    weekday - This result is of type:
  1614. *        Weekdays = (dayerr,Monday,Tuesday,Wednesday,Thursday,Friday,
  1615. *        Saturday,Sunday);
  1616. *        dayerr will show you, that an error occurs!
  1617. *
  1618. *   EXAMPLE
  1619. *    ...
  1620. *    weekday = JulianWeekday(4,10,1582);
  1621. *    if (weekday == dayerr)
  1622. *      {
  1623. *       ...
  1624. *      }
  1625. *    ...
  1626. *
  1627. *   NOTES
  1628. *    It is better only to use this function for years from 1 to 02.1582!
  1629. *    In this version no dayerr will occur!
  1630. *
  1631. *   BUGS
  1632. *    For years <= 0 errors could occur, or systemcrashs(?).
  1633. *
  1634. *   SEE ALSO
  1635. *    GregorianWeekday(),HeisWeekday()
  1636. *
  1637. *****************************************************************************
  1638. *
  1639. *
  1640. */
  1641.  
  1642.  {unsigned short decade,wday;
  1643.  
  1644.   /* January and february dates must be 13 and 14 of the year before! */
  1645.   switch (month)
  1646.     {case 1 :
  1647.      case 2 : month += 12;
  1648.               year--;
  1649.     }
  1650.   decade = (unsigned short)(year - ((year / 100) * 100));
  1651.   /* Formula from Ch. Zeller in 1877 */
  1652.   wday = (unsigned short)((day + (((month+1) * 26) / 10) + decade +
  1653.             (decade / 4) + 5 - (unsigned short)(year / 100)) % 7);
  1654.   /* Convert (1-su 2-mo 3-tu 4-we 5-th 6-fr 7/0-sa) to normal days */
  1655.   if (wday == 0)
  1656.     wday = 6;
  1657.   else
  1658.     {wday--;
  1659.      if (wday == 0)
  1660.        wday = 7;
  1661.     }
  1662.   return((Weekdays)wday);
  1663.  }
  1664.  
  1665.  
  1666.  #ifdef __MakeLib
  1667.    Weekdays __saveds __asm GregorianWeekday(register __d0 const unsigned short day, register __d1 unsigned short month, register __d2 int year)
  1668.  #else
  1669.    Weekdays GregorianWeekday(const unsigned short day, unsigned short month, int year)
  1670.  #endif
  1671.  
  1672. /*
  1673. ******* Date/GregorianWeekday ***********************************************
  1674. *
  1675. *   NAME
  1676. *    GregorianWeekday -- Gets the weekday of a specified date. (V33)
  1677. *
  1678. *   SYNOPSIS
  1679. *    weekday = GregorianWeekday(day,month,year);
  1680. *      d0                d0   d1   d2
  1681. *
  1682. *    Weekdays GregorianWeekday(const unsigned short day,
  1683. *        unsigned short month, int year);
  1684. *
  1685. *   FUNCTION
  1686. *    GregorianWeekday gets the weekday for a specified date.
  1687. *
  1688. *   INPUTS
  1689. *    day   - day of the date
  1690. *    month - month of the date
  1691. *    year  - year of the date
  1692. *
  1693. *   RESULT
  1694. *    weekday - This result is of type:
  1695. *        Weekdays = (dayerr,Monday,Tuesday,Wednesday,Thursday,Friday,
  1696. *        Saturday,Sunday);
  1697. *        dayerr will show you, that an error occurs!
  1698. *
  1699. *   EXAMPLE
  1700. *    ...
  1701. *    weekday = GregorianWeekday(22,1,1994);
  1702. *    if (weekday == dayerr)
  1703. *      {
  1704. *       ...
  1705. *      }
  1706. *    ...
  1707. *
  1708. *   NOTES
  1709. *    It is better only to use this function for years from -7 to 3200!
  1710. *    In this version dayerr will only occur for the lost days :)
  1711. *
  1712. *   BUGS
  1713. *    It's not possible to use years < 0 (for more see JulianWeekday()).
  1714. *
  1715. *   SEE ALSO
  1716. *    JulianWeekday(),HeisWeekday()
  1717. *
  1718. *****************************************************************************
  1719. *
  1720. *
  1721. */
  1722.  
  1723.  {Weekdays weekday;
  1724.   unsigned int wd;
  1725.  
  1726.   if (GregorianDaySmaller(day,month,year,BeforeGregorianDay+1,BeforeGregorianMonth,BeforeGregorianYear))
  1727.     return(JulianWeekday(day,month,year));
  1728.   else
  1729.     {if (GregorianDaySmaller(day,month,year,AfterGregorianDay,AfterGregorianMonth,AfterGregorianYear))
  1730.        return(dayerr);
  1731.      else
  1732.       {if (year==1582)
  1733.          return((Weekdays)((unsigned short)((GregorianDayDiff(15,10,1582,day,month,year)+4)%7)+1));
  1734.        else
  1735.         {/* Formula from J. I. Perelman 1909 */
  1736.          wd = year + (year / 4) - (year / 100) + (year / 400)
  1737.                 + (int)GregorianDayDiff(1,1,year,day,month,year);
  1738.          if (GregorianLeapYear(year))
  1739.            wd--;
  1740.          weekday = (Weekdays)(wd % 7);
  1741.          if (weekday == dayerr)
  1742.            weekday = Sunday;
  1743.          return(weekday);
  1744.         }
  1745.       }
  1746.     }
  1747.  }
  1748.  
  1749.  
  1750.  #ifdef __MakeLib
  1751.    Weekdays __saveds __asm HeisWeekday(register __d0 const unsigned short day, register __d1 unsigned short month, register __d2 int year)
  1752.  #else
  1753.    Weekdays HeisWeekday(const unsigned short day, unsigned short month, int year)
  1754.  #endif
  1755.  
  1756. /*
  1757. ******* Date/HeisWeekday ****************************************************
  1758. *
  1759. *   NAME
  1760. *    HeisWeekday -- Gets the weekday of a specified date. (V33)
  1761. *
  1762. *   SYNOPSIS
  1763. *    weekday = HeisWeekday(day,month,year);
  1764. *      d0               d0   d1   d2
  1765. *
  1766. *    Weekdays HeisWeekday(const unsigned short day, unsigned short month,
  1767. *        int year);
  1768. *
  1769. *   FUNCTION
  1770. *    HeisWeekday gets the weekday for a specified date.
  1771. *
  1772. *   INPUTS
  1773. *    day   - day of the date
  1774. *    month - month of the date
  1775. *    year  - year of the date
  1776. *
  1777. *   RESULT
  1778. *    weekday - This result is of type:
  1779. *        Weekdays = (dayerr,Monday,Tuesday,Wednesday,Thursday,Friday,
  1780. *        Saturday,Sunday);
  1781. *        dayerr will show you, that an error occurs!
  1782. *
  1783. *   EXAMPLE
  1784. *    ...
  1785. *    weekday = HeisWeekday(22,1,1994);
  1786. *    if (weekday == dayerr)
  1787. *      {
  1788. *       ...
  1789. *      }
  1790. *    ...
  1791. *
  1792. *   NOTES
  1793. *    It is better only to use this function for years from -7 to 8000!
  1794. *    In this version dayerr will only occur for the lost days :)
  1795. *
  1796. *   BUGS
  1797. *    It is not possible to use year < 0 (see JulianWeekday() for more).
  1798. *
  1799. *   SEE ALSO
  1800. *    JulianWeekday(),GregorianWeekday()
  1801. *
  1802. *****************************************************************************
  1803. *
  1804. *
  1805. */
  1806.  
  1807.  {Weekdays weekday;
  1808.   unsigned int wd;
  1809.  
  1810.   if (HeisDaySmaller(day,month,year,StartHeisDay,StartHeisMonth,StartHeisYear))
  1811.     return(GregorianWeekday(day,month,year));
  1812.   else
  1813.     {/* Formula from J. I. Perelman 1909 - extended for N.Heis in 01.1994
  1814.     by Kai Hofmann */
  1815.      wd = year + (year / 4) - (year / 100) + (year / 400)
  1816.         - (year / 3200) + (int)HeisDayDiff(1,1,year,day,month,year);
  1817.      if (HeisLeapYear(year))
  1818.        wd--;
  1819.      weekday = (Weekdays)(wd % 7);
  1820.      if (weekday == dayerr)
  1821.        weekday = Sunday;
  1822.      return(weekday);
  1823.     }
  1824.  }
  1825.  
  1826.  /* ----------------------------------------------------------------------- */
  1827.  
  1828.  #ifdef __MakeLib
  1829.    unsigned short __saveds __asm JulianDaysBeforeWeekday(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 const Weekdays weekday)
  1830.  #else
  1831.    unsigned short JulianDaysBeforeWeekday(const unsigned short day, const unsigned short month, const int year, const Weekdays weekday)
  1832.  #endif
  1833.  
  1834. /*
  1835. ******* Date/JulianDaysBeforeWeekday ****************************************
  1836. *
  1837. *   NAME
  1838. *    JulianDaysBeforeWeekday -- Returns the diff to the wday before. (V33)
  1839. *
  1840. *   SYNOPSIS
  1841. *    days = JulianDaysBeforeWeekday(day,month,year,weekday);
  1842. *     d0                d0  d1    d2    d3
  1843. *
  1844. *    unsigned short JulianDaysBeforeWeekday(const unsigned short day,
  1845. *        const unsigned short month, const int year,
  1846. *        const Weekdays weekday);
  1847. *
  1848. *   FUNCTION
  1849. *    Returns the days to the weekday before the specified date.
  1850. *    So if you specify the 22.1.1994 (Saturday) and Thursday
  1851. *    you get back 2!
  1852. *    If you specify the 22.1.1994 and Saturday you get back 0
  1853. *    (the same day)!
  1854. *
  1855. *   INPUTS
  1856. *    day     - day of the date
  1857. *    month   - month of the date
  1858. *    year    - year of the date
  1859. *    weekday - weekday to search for building difference
  1860. *
  1861. *   RESULT
  1862. *    days - The days back to the searched weekday (0-6)
  1863. *        If you get back 8 an error occurs!
  1864. *
  1865. *   EXAMPLE
  1866. *    ...
  1867. *    days = JulianDaysBeforeWeekday(22,1,1994,Thursday);
  1868. *    ...
  1869. *
  1870. *   NOTES
  1871. *    It is better to use this function only from -7 to 02.1582!
  1872. *
  1873. *   BUGS
  1874. *    See JulianWeekday()!
  1875. *
  1876. *   SEE ALSO
  1877. *    JulianWeekday(),GregorianDaysBeforeWeekday(),HeisDaysBeforeWeekday()
  1878. *
  1879. *****************************************************************************
  1880. *
  1881. *
  1882. */
  1883.  
  1884.  {Weekdays wday;
  1885.  
  1886.   if (weekday == dayerr)
  1887.     return(8);
  1888.   else
  1889.     {wday = JulianWeekday(day,month,year);
  1890.      if (wday >= weekday)
  1891.        return((unsigned short)(wday-weekday));
  1892.      else
  1893.        {/* wday < weekday */
  1894.         return((unsigned short)(7-weekday+wday));
  1895.        }
  1896.     }
  1897.  }
  1898.  
  1899.  
  1900.  #ifdef __MakeLib
  1901.    unsigned short __saveds __asm GregorianDaysBeforeWeekday(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 const Weekdays weekday)
  1902.  #else
  1903.    unsigned short GregorianDaysBeforeWeekday(const unsigned short day, const unsigned short month, const int year, const Weekdays weekday)
  1904.  #endif
  1905.  
  1906. /*
  1907. ******* Date/GregorianDaysBeforeWeekday *************************************
  1908. *
  1909. *   NAME
  1910. *    GregorianDaysBeforeWeekday -- Returns the diff to wday before. (V33)
  1911. *
  1912. *   SYNOPSIS
  1913. *    days = GregorianDaysBeforeWeekday(day,month,year,weekday);
  1914. *     d0                   d0  d1    d2    d3
  1915. *
  1916. *    unsigned short GregorianDaysBeforeWeekday(const unsigned short day,
  1917. *        const unsigned short month, const int year,
  1918. *        const Weekdays weekday);
  1919. *
  1920. *   FUNCTION
  1921. *    Returns the days to the weekday before the specified date.
  1922. *    So if you specify the 22.1.1994 (Saturday) and Thursday
  1923. *    you get back 2!
  1924. *    If you specify the 22.1.1994 and Saturday you get back 0
  1925. *    (the same day)!
  1926. *
  1927. *   INPUTS
  1928. *    day     - day of the date
  1929. *    month   - month of the date
  1930. *    year    - year of the date
  1931. *    weekday - weekday to search for building difference
  1932. *
  1933. *   RESULT
  1934. *    days - The days back to the searched weekday (1-7)
  1935. *        If you get back 8 an error occurs!
  1936. *
  1937. *   EXAMPLE
  1938. *    ...
  1939. *    days = GregorianDaysBeforeWeekday(22,1,1994,Thursday);
  1940. *    ...
  1941. *
  1942. *   NOTES
  1943. *    It is better to use this function only from -7 to 3200!
  1944. *
  1945. *   BUGS
  1946. *    See GregorianWeekday()!
  1947. *
  1948. *   SEE ALSO
  1949. *    GregorianWeekday(),JulianDaysBeforeWeekday(),HeisDaysBeforeWeekday()
  1950. *
  1951. *****************************************************************************
  1952. *
  1953. *
  1954. */
  1955.  
  1956.  {Weekdays wday;
  1957.  
  1958.   if (weekday == dayerr)
  1959.     return(8);
  1960.   else
  1961.     {wday = GregorianWeekday(day,month,year);
  1962.      if (wday >= weekday)
  1963.        return((unsigned short)(wday-weekday));
  1964.      else
  1965.        {/* wday < weekday */
  1966.         return((unsigned short)(7-weekday+wday));
  1967.        }
  1968.     }
  1969.  }
  1970.  
  1971.  
  1972.  #ifdef __MakeLib
  1973.    unsigned short __saveds __asm HeisDaysBeforeWeekday(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 const Weekdays weekday)
  1974.  #else
  1975.    unsigned short HeisDaysBeforeWeekday(const unsigned short day, const unsigned short month, const int year, const Weekdays weekday)
  1976.  #endif
  1977.  
  1978. /*
  1979. ******* Date/HeisDaysBeforeWeekday ******************************************
  1980. *
  1981. *   NAME
  1982. *    HeisDaysBeforeWeekday -- Returns the diff to wday before. (V33)
  1983. *
  1984. *   SYNOPSIS
  1985. *    days = HeisDaysBeforeWeekday(day,month,year,weekday);
  1986. *     d0                  d0  d1    d2    d3
  1987. *
  1988. *    unsigned short HeisDaysBeforeWeekday(const unsigned short day,
  1989. *        const unsigned short month, const int year,
  1990. *        const Weekdays weekday);
  1991. *
  1992. *   FUNCTION
  1993. *    Returns the days to the weekday before the specified date.
  1994. *    So if you specify the 22.1.1994 (Saturday) and Thursday
  1995. *    you get back 2!
  1996. *    If you specify the 22.1.1994 and Saturday you get back 0
  1997. *    (the same day)!
  1998. *
  1999. *   INPUTS
  2000. *    day     - day of the date
  2001. *    month   - month of the date
  2002. *    year    - year of the date
  2003. *    weekday - weekday to search for building difference
  2004. *
  2005. *   RESULT
  2006. *    days - The days back to the searched weekday (1-7)
  2007. *        If you get back 8 an error occurs!
  2008. *
  2009. *   EXAMPLE
  2010. *    ...
  2011. *    days = HeisDaysBeforeWeekday(22,1,1994,Thursday);
  2012. *    ...
  2013. *
  2014. *   NOTES
  2015. *    It is better to use this function only from -7 to 8000!
  2016. *
  2017. *   BUGS
  2018. *    See HeisWeekday()!
  2019. *
  2020. *   SEE ALSO
  2021. *    HeisWeekday(),JulianDaysBeforeWeekday(),GregorianDaysBeforeWeekday()
  2022. *
  2023. *****************************************************************************
  2024. *
  2025. *
  2026. */
  2027.  
  2028.  {Weekdays wday;
  2029.  
  2030.   if (weekday == dayerr)
  2031.     return(8);
  2032.   else
  2033.     {wday = HeisWeekday(day,month,year);
  2034.      if (wday >= weekday)
  2035.        return((unsigned short)(wday-weekday));
  2036.      else
  2037.        {/* wday < weekday */
  2038.         return((unsigned short)(7-weekday+wday));
  2039.        }
  2040.     }
  2041.  }
  2042.  
  2043.  /* ----------------------------------------------------------------------- */
  2044.  
  2045.  #ifdef __MakeLib
  2046.    unsigned short __saveds __asm JulianDaysAfterWeekday(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 const Weekdays weekday)
  2047.  #else
  2048.    unsigned short JulianDaysAfterWeekday(const unsigned short day, const unsigned short month, const int year, const Weekdays weekday)
  2049.  #endif
  2050.  
  2051. /*
  2052. ******* Date/JulianDaysAfterWeekday *****************************************
  2053. *
  2054. *   NAME
  2055. *    JulianDaysAfterWeekday -- Returns the diff to the wday after. (V33)
  2056. *
  2057. *   SYNOPSIS
  2058. *    days = JulianDaysAfterWeekday(day,month,year,weekday);
  2059. *     d0                   d0   d1   d2     d3
  2060. *
  2061. *    unsigned short JulianDaysAfterWeekday(const unsigned short day,
  2062. *        const unsigned short month, const int year,
  2063. *        const Weekdays weekday);
  2064. *
  2065. *   FUNCTION
  2066. *    Returns the days to the weekday after the specified date.
  2067. *    So if you specify the 22.1.1994 (Saturday) and Thursday
  2068. *    you get back 5!
  2069. *    If you specify the 22.1.1994 and Saturday you get back 0
  2070. *    (the same day)!
  2071. *
  2072. *   INPUTS
  2073. *    day     - day of the date
  2074. *    month   - month of the date
  2075. *    year    - year of the date
  2076. *    weekday - weekday to search for building difference
  2077. *
  2078. *   RESULT
  2079. *    days - The days after to the searched weekday.
  2080. *
  2081. *   EXAMPLE
  2082. *    ...
  2083. *    days = JulianDaysAfterWeekday(22,1,1994,Thursday);
  2084. *    ...
  2085. *
  2086. *   NOTES
  2087. *    It is better to use this function only from -7 to 1582!
  2088. *
  2089. *   BUGS
  2090. *    See JulianWeekday()!
  2091. *
  2092. *   SEE ALSO
  2093. *    JulianWeekday(),GregorianDaysAfterWeekday(),HeisDaysAfterWeekday()
  2094. *
  2095. *****************************************************************************
  2096. *
  2097. *
  2098. */
  2099.  
  2100.  {Weekdays wday;
  2101.  
  2102.   if (weekday == dayerr)
  2103.     return(8);
  2104.   else
  2105.     {wday = JulianWeekday(day,month,year);
  2106.      if (wday <= weekday)
  2107.        return((unsigned short)(weekday-wday));
  2108.      else
  2109.        {/* wday > weekday */
  2110.         return((unsigned short)(7-wday+weekday));
  2111.        }
  2112.     }
  2113.  }
  2114.  
  2115.  
  2116.  #ifdef __MakeLib
  2117.    unsigned short __saveds __asm GregorianDaysAfterWeekday(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 const Weekdays weekday)
  2118.  #else
  2119.    unsigned short GregorianDaysAfterWeekday(const unsigned short day, const unsigned short month, const int year, const Weekdays weekday)
  2120.  #endif
  2121.  
  2122. /*
  2123. ******* Date/GregorianDaysAfterWeekday **************************************
  2124. *
  2125. *   NAME
  2126. *    GregorianDaysAfterWeekday -- Returns the diff to wday after. (V33)
  2127. *
  2128. *   SYNOPSIS
  2129. *    days = GregorianDaysAfterWeekday(day,month,year,weekday);
  2130. *     d0                      d0   d1   d2     d3
  2131. *
  2132. *    unsigned short GregorianDaysAfterWeekday(const unsigned short day,
  2133. *        const unsigned short month, const int year,
  2134. *        const Weekdays weekday);
  2135. *
  2136. *   FUNCTION
  2137. *    Returns the days to the weekday after the specified date.
  2138. *    So if you specify the 22.1.1994 (Saturday) and Thursday
  2139. *    you get back 5!
  2140. *    If you specify the 22.1.1994 and Saturday you get back 0
  2141. *    (the same day)!
  2142. *
  2143. *   INPUTS
  2144. *    day     - day of the date
  2145. *    month   - month of the date
  2146. *    year    - year of the date
  2147. *    weekday - weekday to search for building difference
  2148. *
  2149. *   RESULT
  2150. *    days - The days after to the searched weekday.
  2151. *
  2152. *   EXAMPLE
  2153. *    ...
  2154. *    days = GregorianDaysAfterWeekday(22,1,1994,Thursday);
  2155. *    ...
  2156. *
  2157. *   NOTES
  2158. *    It is better to use this function only from -7 to 3200!
  2159. *
  2160. *   BUGS
  2161. *    See GregorianWeekday()!
  2162. *
  2163. *   SEE ALSO
  2164. *    GregorianWeekday(),JulianDaysAfterWeekday(),HeisDaysAfterWeekday()
  2165. *
  2166. *****************************************************************************
  2167. *
  2168. *
  2169. */
  2170.  
  2171.  {Weekdays wday;
  2172.  
  2173.   if (weekday == dayerr)
  2174.     return(8);
  2175.   else
  2176.     {wday = GregorianWeekday(day,month,year);
  2177.      if (wday <= weekday)
  2178.        return((unsigned short)(weekday-wday));
  2179.      else
  2180.        {/* wday > weekday */
  2181.         return((unsigned short)(7-wday+weekday));
  2182.        }
  2183.     }
  2184.  }
  2185.  
  2186.  
  2187.  #ifdef __MakeLib
  2188.    unsigned short __saveds __asm HeisDaysAfterWeekday(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 const Weekdays weekday)
  2189.  #else
  2190.    unsigned short HeisDaysAfterWeekday(const unsigned short day, const unsigned short month, const int year, const Weekdays weekday)
  2191.  #endif
  2192.  
  2193. /*
  2194. ******* Date/HeisDaysAfterWeekday *******************************************
  2195. *
  2196. *   NAME
  2197. *    HeisDaysAfterWeekday -- Returns the diff to the wday after. (V33)
  2198. *
  2199. *   SYNOPSIS
  2200. *    days = HeisDaysAfterWeekday(day,month,year,weekday);
  2201. *     d0                 d0   d1   d2     d3
  2202. *
  2203. *    unsigned short HeisDaysAfterWeekday(const unsigned short day,
  2204. *        const unsigned short month, const int year,
  2205. *        const Weekdays weekday);
  2206. *
  2207. *   FUNCTION
  2208. *    Returns the days to the weekday after the specified date.
  2209. *    So if you specify the 22.1.1994 (Saturday) and Thursday
  2210. *    you get back 5!
  2211. *    If you specify the 22.1.1994 and Saturday you get back 0
  2212. *    (the same day)!
  2213. *
  2214. *   INPUTS
  2215. *    day     - day of the date
  2216. *    month   - month of the date
  2217. *    year    - year of the date
  2218. *    weekday - weekday to search for building difference
  2219. *
  2220. *   RESULT
  2221. *    days - The days after to the searched weekday.
  2222. *
  2223. *   EXAMPLE
  2224. *    ...
  2225. *    days = HeisDaysAfterWeekday(22,1,1994,Thursday);
  2226. *    ...
  2227. *
  2228. *   NOTES
  2229. *    It is better to use this function only from -7 to 8000!
  2230. *
  2231. *   BUGS
  2232. *    See HeisWeekday()!
  2233. *
  2234. *   SEE ALSO
  2235. *    HeisWeekday(),JulianDaysAfterWeekday(),GregorianDaysAfterWeekday()
  2236. *
  2237. *****************************************************************************
  2238. *
  2239. *
  2240. */
  2241.  
  2242.  {Weekdays wday;
  2243.  
  2244.   if (weekday == dayerr)
  2245.     return(8);
  2246.   else
  2247.     {wday = HeisWeekday(day,month,year);
  2248.      if (wday <= weekday)
  2249.        return((unsigned short)(weekday-wday));
  2250.      else
  2251.        {/* wday > weekday */
  2252.         return((unsigned short)(7-wday+weekday));
  2253.        }
  2254.     }
  2255.  }
  2256.  
  2257.  /* ----------------------------------------------------------------------- */
  2258.  
  2259.  #ifdef __MakeLib
  2260.    void __saveds __asm JulianDiffDate(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 int days, register __a0 unsigned short *dday, register __a1 unsigned short *dmonth, register __a2 int *dyear)
  2261.  #else
  2262.    void JulianDiffDate(const unsigned short day, const unsigned short month, const int year, int days, unsigned short *dday, unsigned short *dmonth, int *dyear)
  2263.  #endif
  2264.  
  2265. /*
  2266. ******* Date/JulianDiffDate *************************************************
  2267. *
  2268. *   NAME
  2269. *    JulianDiffDate -- Returns the date for a diff to another date. (V33)
  2270. *
  2271. *   SYNOPSIS
  2272. *    JulianDiffDate(day,month,year,diffdays,dday,dmonth,dyear);
  2273. *            d0   d1   d2     d3     a0    a1    a2
  2274. *
  2275. *    void JulianDiffDate(const unsigned short day,
  2276. *        const unsigned short month, const int year, int days,
  2277. *        unsigned short *dday, unsigned short *dmonth, int *dyear);
  2278. *
  2279. *   FUNCTION
  2280. *    Returns the date which lies diffdays before/after the specified date.
  2281. *
  2282. *   INPUTS
  2283. *    day      - day of the date
  2284. *    month    - month of the date
  2285. *    year     - year of the date
  2286. *    diffdays - difference to the date in days
  2287. *
  2288. *   RESULT
  2289. *    dday   - Destination day
  2290. *    dmonth - Destination month
  2291. *    dyear  - Destination year
  2292. *
  2293. *   EXAMPLE
  2294. *    ...
  2295. *    JulianDiffDate(23,1,1994,7,&dday,&dmonth,&dyear);
  2296. *    ...
  2297. *
  2298. *   NOTES
  2299. *    It is better to use this function only from -7 to 1582!
  2300. *
  2301. *   BUGS
  2302. *    unknown.
  2303. *
  2304. *   SEE ALSO
  2305. *    JulianDayDiff(),JulianMonthDays(),GregorianDiffDate(),HeisDiffDate()
  2306. *
  2307. *****************************************************************************
  2308. *
  2309. *
  2310. */
  2311.  
  2312.  {int ddays;
  2313.  
  2314.   *dday = day;
  2315.   *dmonth = month;
  2316.   *dyear = year;
  2317.   if (days >= 0)
  2318.     {/* add */
  2319.      ddays = (int)JulianDayDiff(*dday,*dmonth,*dyear,1,1,(*dyear)+1);
  2320.      while (days >= ddays)
  2321.        {/* years */
  2322.         *dday = 1;
  2323.         *dmonth = 1;
  2324.         (*dyear)++;
  2325.         days -= ddays;
  2326.         ddays = (int)JulianDayDiff(*dday,*dmonth,*dyear,1,1,(*dyear)+1);
  2327.        }
  2328.      ddays = (int)JulianDayDiff(*dday,*dmonth,*dyear,1,(*dmonth)+1,*dyear);
  2329.      while (days >= ddays)
  2330.        {/* months */
  2331.         *dday = 1;
  2332.         (*dmonth)++;
  2333.         days -= ddays;
  2334.         ddays = (int)JulianDayDiff(*dday,*dmonth,*dyear,1,(*dmonth)+1,*dyear);
  2335.        }
  2336.      if (days > 0)
  2337.        {/* days */
  2338.         *dday += (unsigned short)days;
  2339.        }
  2340.     }
  2341.   else
  2342.     {/* sub */
  2343.      ddays = (int)JulianDayDiff(*dday,*dmonth,*dyear,31,12,(*dyear)-1);
  2344.      while (days <= ddays)
  2345.        {/* years */
  2346.         *dday = 31;
  2347.         *dmonth = 12;
  2348.         (*dyear)--;
  2349.         days -= ddays;
  2350.         ddays = (int)JulianDayDiff(*dday,*dmonth,*dyear,31,12,(*dyear)-1);
  2351.        }
  2352.      ddays = (int)JulianDayDiff(*dday,*dmonth,*dyear,JulianMonthDays((*dmonth)-1,*dyear),(*dmonth)-1,*dyear);
  2353.      while (days <= ddays)
  2354.        {/* months */
  2355.         *dday = JulianMonthDays((*dmonth)-1,*dyear);
  2356.         (*dmonth)--;
  2357.         days -= ddays;
  2358.         ddays = (int)JulianDayDiff(*dday,*dmonth,*dyear,JulianMonthDays((*dmonth)-1,*dyear),(*dmonth)-1,*dyear);
  2359.        }
  2360.      if (days < 0)
  2361.        *dday -= (unsigned short)abs(days);
  2362.     }
  2363.  }
  2364.  
  2365.  
  2366.  #ifdef __MakeLib
  2367.    void __saveds __asm GregorianDiffDate(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 int days, register __a0 unsigned short *dday, register __a1 unsigned short *dmonth, register __a2 int *dyear)
  2368.  #else
  2369.    void GregorianDiffDate(const unsigned short day, const unsigned short month, const int year, int days, unsigned short *dday, unsigned short *dmonth, int *dyear)
  2370.  #endif
  2371.  
  2372. /*
  2373. ******* Date/GregorianDiffDate **********************************************
  2374. *
  2375. *   NAME
  2376. *    GregorianDiffDate -- Returns the diff date to another date. (V33)
  2377. *
  2378. *   SYNOPSIS
  2379. *    GregorianDiffDate(day,month,year,diffdays,dday,dmonth,dyear);
  2380. *               d0   d1   d2     d3     a0    a1    a2
  2381. *
  2382. *    void GregorianDiffDate(const unsigned short day,
  2383. *        const unsigned short month, const int year, int days,
  2384. *        unsigned short *dday, unsigned short *dmonth, int *dyear);
  2385. *
  2386. *   FUNCTION
  2387. *    Returns the date which lies diffdays before/after the specified date.
  2388. *
  2389. *   INPUTS
  2390. *    day      - day of the date
  2391. *    month    - month of the date
  2392. *    year     - year of the date
  2393. *    diffdays - difference to the date in days
  2394. *
  2395. *   RESULT
  2396. *    dday   - Destination day
  2397. *    dmonth - Destination month
  2398. *    dyear  - Destination year
  2399. *
  2400. *   EXAMPLE
  2401. *    ...
  2402. *    GregorianDiffDate(23,1,1994,7,&dday,&dmonth,&dyear);
  2403. *    ...
  2404. *
  2405. *   NOTES
  2406. *    It is better to use this function only from -7 to 3200!
  2407. *
  2408. *   BUGS
  2409. *    unknown.
  2410. *
  2411. *   SEE ALSO
  2412. *    GregorianDayDiff(),GregorianMonthDays(),JulianDiffDate(),
  2413. *    HeisDiffDate()
  2414. *
  2415. *****************************************************************************
  2416. *
  2417. *
  2418. */
  2419.  
  2420.  {int ddays;
  2421.  
  2422.   *dday = day;
  2423.   *dmonth = month;
  2424.   *dyear = year;
  2425.   if (days >= 0)
  2426.     {/* add */
  2427.      ddays = (int)GregorianDayDiff(*dday,*dmonth,*dyear,1,1,(*dyear)+1);
  2428.      while (days >= ddays)
  2429.        {/* years */
  2430.         *dday = 1;
  2431.         *dmonth = 1;
  2432.         (*dyear)++;
  2433.         days -= ddays;
  2434.         ddays = (int)GregorianDayDiff(*dday,*dmonth,*dyear,1,1,(*dyear)+1);
  2435.        }
  2436.      ddays = (int)GregorianDayDiff(*dday,*dmonth,*dyear,1,(*dmonth)+1,*dyear);
  2437.      while (days >= ddays)
  2438.        {/* months */
  2439.         *dday = 1;
  2440.         (*dmonth)++;
  2441.         days -= ddays;
  2442.         ddays = (int)GregorianDayDiff(*dday,*dmonth,*dyear,1,(*dmonth)+1,*dyear);
  2443.        }
  2444.      if (days > 0)
  2445.        {/* days */
  2446.         *dday += (unsigned short)days;
  2447.        }
  2448.     }
  2449.   else
  2450.     {/* sub */
  2451.      ddays = (int)GregorianDayDiff(*dday,*dmonth,*dyear,31,12,(*dyear)-1);
  2452.      while (days <= ddays)
  2453.        {/* years */
  2454.         *dday = 31;
  2455.         *dmonth = 12;
  2456.         (*dyear)--;
  2457.         days -= ddays;
  2458.         ddays = (int)GregorianDayDiff(*dday,*dmonth,*dyear,31,12,(*dyear)-1);
  2459.        }
  2460.      ddays = (int)GregorianDayDiff(*dday,*dmonth,*dyear,GregorianMonthDays((*dmonth)-1,*dyear),(*dmonth-1),*dyear);
  2461.      while (days <= ddays)
  2462.        {/* months */
  2463.         *dday = GregorianMonthDays((*dmonth-1),*dyear);
  2464.         (*dmonth)--;
  2465.         days -= ddays;
  2466.         ddays = (int)GregorianDayDiff(*dday,*dmonth,*dyear,GregorianMonthDays((*dmonth)-1,*dyear),(*dmonth)-1,*dyear);
  2467.        }
  2468.      if (days < 0)
  2469.        *dday -= (unsigned short)abs(days);
  2470.     }
  2471.  }
  2472.  
  2473.  
  2474.  #ifdef __MakeLib
  2475.    void __saveds __asm HeisDiffDate(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year, register __d3 int days, register __a0 unsigned short *dday, register __a1 unsigned short *dmonth, register __a2 int *dyear)
  2476.  #else
  2477.    void HeisDiffDate(const unsigned short day, const unsigned short month, const int year, int days, unsigned short *dday, unsigned short *dmonth, int *dyear)
  2478.  #endif
  2479.  
  2480. /*
  2481. ******* Date/HeisDiffDate ***************************************************
  2482. *
  2483. *   NAME
  2484. *    HeisDiffDate -- Returns the date for a diff to another date. (V33)
  2485. *
  2486. *   SYNOPSIS
  2487. *    HeisDiffDate(day,month,year,diffdays,dday,dmonth,dyear);
  2488. *              d0   d1   d2     d3     a0    a1    a2
  2489. *
  2490. *    void HeisDiffDate(const unsigned short day,
  2491. *        const unsigned short month, const int year, int days,
  2492. *        unsigned short *dday, unsigned short *dmonth, int *dyear);
  2493. *
  2494. *   FUNCTION
  2495. *    Returns the date which lies diffdays before/after the specified date.
  2496. *
  2497. *   INPUTS
  2498. *    day      - day of the date
  2499. *    month    - month of the date
  2500. *    year     - year of the date
  2501. *    diffdays - difference to the date in days
  2502. *
  2503. *   RESULT
  2504. *    dday   - Destination day
  2505. *    dmonth - Destination month
  2506. *    dyear  - Destination year
  2507. *
  2508. *   EXAMPLE
  2509. *    ...
  2510. *    HeisDiffDate(23,1,1994,7,&dday,&dmonth,&dyear);
  2511. *    ...
  2512. *
  2513. *   NOTES
  2514. *    It is better to use this function only from -7 to 8000!
  2515. *
  2516. *   BUGS
  2517. *    unknown.
  2518. *
  2519. *   SEE ALSO
  2520. *    HeisDayDiff(),HeisMonthDays(),JulianDiffDate(),GregorianDiffDate()
  2521. *
  2522. *****************************************************************************
  2523. *
  2524. *
  2525. */
  2526.  
  2527.  {int ddays;
  2528.  
  2529.   *dday = day;
  2530.   *dmonth = month;
  2531.   *dyear = year;
  2532.   if (days >= 0)
  2533.     {/* add */
  2534.      ddays = (int)HeisDayDiff(*dday,*dmonth,*dyear,1,1,(*dyear)+1);
  2535.      while (days >= ddays)
  2536.        {/* years */
  2537.         *dday = 1;
  2538.         *dmonth = 1;
  2539.         (*dyear)++;
  2540.         days -= ddays;
  2541.         ddays = (int)HeisDayDiff(*dday,*dmonth,*dyear,1,1,(*dyear)+1);
  2542.        }
  2543.      ddays = (int)HeisDayDiff(*dday,*dmonth,*dyear,1,(*dmonth+1),*dyear);
  2544.      while (days >= ddays)
  2545.        {/* months */
  2546.         *dday = 1;
  2547.         (*dmonth)++;
  2548.         days -= ddays;
  2549.         ddays = (int)HeisDayDiff(*dday,*dmonth,*dyear,1,(*dmonth)+1,*dyear);
  2550.        }
  2551.      if (days > 0)
  2552.        {/* days */
  2553.         *dday += (unsigned short)days;
  2554.        }
  2555.     }
  2556.   else
  2557.     {/* sub */
  2558.      ddays = (int)HeisDayDiff(*dday,*dmonth,*dyear,31,12,(*dyear)-1);
  2559.      while (days <= ddays)
  2560.        {/* years */
  2561.         *dday = 31;
  2562.         *dmonth = 12;
  2563.         (*dyear)--;
  2564.         days -= ddays;
  2565.         ddays = (int)HeisDayDiff(*dday,*dmonth,*dyear,31,12,(*dyear)-1);
  2566.        }
  2567.      ddays = (int)HeisDayDiff(*dday,*dmonth,*dyear,HeisMonthDays((*dmonth)-1,*dyear),(*dmonth)-1,*dyear);
  2568.      while (days <= ddays)
  2569.        {/* months */
  2570.         *dday = HeisMonthDays((*dmonth)-1,*dyear);
  2571.         (*dmonth)--;
  2572.         days -= ddays;
  2573.         ddays = (int)HeisDayDiff(*dday,*dmonth,*dyear,HeisMonthDays((*dmonth)-1,*dyear),(*dmonth)-1,*dyear);
  2574.        }
  2575.      if (days < 0)
  2576.        *dday -= (unsigned short)abs(days);
  2577.     }
  2578.  }
  2579.  
  2580.  /* ----------------------------------------------------------------------- */
  2581.  
  2582.  #ifdef __MakeLib
  2583.    unsigned int __saveds __asm JYearToScaliger(register __d0 const int year)
  2584.  #else
  2585.    unsigned int JYearToScaliger(const int year)
  2586.  #endif
  2587.  
  2588. /*
  2589. ******* Date/JYearToScaliger ************************************************
  2590. *
  2591. *   NAME
  2592. *    JYearToScaliger -- Returns the year as Scaliger year. (V33)
  2593. *
  2594. *   SYNOPSIS
  2595. *    syear = JYearToScaliger(year);
  2596. *     d0             d0
  2597. *
  2598. *    unsigned int JYearToScaliger(const int year);
  2599. *
  2600. *   FUNCTION
  2601. *    Returns the Scaliger year.
  2602. *
  2603. *   INPUTS
  2604. *    year     - Julian year
  2605. *
  2606. *   RESULT
  2607. *    syear - The Scaliger year
  2608. *
  2609. *   EXAMPLE
  2610. *    ...
  2611. *    syear = JYearToScaliger(1582);
  2612. *    ...
  2613. *
  2614. *   NOTES
  2615. *    It is better to use this function only from -7 to 1582!
  2616. *
  2617. *   BUGS
  2618. *    unknown.
  2619. *
  2620. *   SEE ALSO
  2621. *    GYearToScaliger(),HYearToScaliger()
  2622. *
  2623. *****************************************************************************
  2624. *
  2625. *
  2626. */
  2627.  
  2628.  {if ((year < 0) && (year > -4714))
  2629.     return((unsigned int)(4714+year));
  2630.   else
  2631.     if ((year > 0) && (year < 3268))
  2632.       return((unsigned int)(4713+year));
  2633.     else
  2634.       return(0);
  2635.  }
  2636.  
  2637.  
  2638.  #ifdef __MakeLib
  2639.    unsigned int __saveds __asm GYearToScaliger(register __d0 const int year)
  2640.  #else
  2641.    unsigned int GYearToScaliger(const int year)
  2642.  #endif
  2643.  
  2644. /*
  2645. ******* Date/GYearToScaliger ************************************************
  2646. *
  2647. *   NAME
  2648. *    GYearToScaliger -- Returns the year as Scaliger year. (V33)
  2649. *
  2650. *   SYNOPSIS
  2651. *    syear = GYearToScaliger(year);
  2652. *     d0             d0
  2653. *
  2654. *    unsigned int GYearToScaliger(const int year);
  2655. *
  2656. *   FUNCTION
  2657. *    Returns the Scaliger year.
  2658. *
  2659. *   INPUTS
  2660. *    year     - Gregorian year
  2661. *
  2662. *   RESULT
  2663. *    syear - The Scaliger year
  2664. *
  2665. *   EXAMPLE
  2666. *    ...
  2667. *    syear = GYearToScaliger(1994);
  2668. *    ...
  2669. *
  2670. *   NOTES
  2671. *    It is better to use this function only from -7 to 3200!
  2672. *
  2673. *   BUGS
  2674. *    unknown.
  2675. *
  2676. *   SEE ALSO
  2677. *    JYearToScaliger(),HYearToScaliger()
  2678. *
  2679. *****************************************************************************
  2680. *
  2681. *
  2682. */
  2683.  
  2684.  {/* if other calcs are better use here! */
  2685.   return(JYearToScaliger(year));
  2686.  }
  2687.  
  2688.  
  2689.  #ifdef __MakeLib
  2690.    unsigned int __saveds __asm HYearToScaliger(register __d0 const int year)
  2691.  #else
  2692.    unsigned int HYearToScaliger(const int year)
  2693.  #endif
  2694.  
  2695. /*
  2696. ******* Date/HYearToScaliger ************************************************
  2697. *
  2698. *   NAME
  2699. *    HYearToScaliger -- Returns the year as Scaliger year. (V33)
  2700. *
  2701. *   SYNOPSIS
  2702. *    syear = HYearToScaliger(year);
  2703. *     d0             d0
  2704. *
  2705. *    unsigned int HYearToScaliger(const int year);
  2706. *
  2707. *   FUNCTION
  2708. *    Returns the Scaliger year.
  2709. *
  2710. *   INPUTS
  2711. *    year     - Heis year
  2712. *
  2713. *   RESULT
  2714. *    syear - The Scaliger year
  2715. *
  2716. *   EXAMPLE
  2717. *    ...
  2718. *    syear = HYearToScaliger(1994);
  2719. *    ...
  2720. *
  2721. *   NOTES
  2722. *    It is better to use this function only from -7 to 8000!
  2723. *
  2724. *   BUGS
  2725. *    The Scaliger period is defined to 3268!!!.
  2726. *
  2727. *   SEE ALSO
  2728. *    JYearToScaliger(),GYearToScaliger()
  2729. *
  2730. *****************************************************************************
  2731. *
  2732. *
  2733. */
  2734.  
  2735.  {/* for compatiblities if GYearToScaliger will be changed */
  2736.   return(GYearToScaliger(year));
  2737.  }
  2738.  
  2739.  /* ----------------------------------------------------------------------- */
  2740.  
  2741.  #ifdef __MakeLib
  2742.    int __saveds __asm ScaligerYearToJ(register __d0 const unsigned int syear)
  2743.  #else
  2744.    int ScaligerYearToJ(const unsigned int syear)
  2745.  #endif
  2746.  
  2747. /*
  2748. ******* Date/ScaligerYearToJ ************************************************
  2749. *
  2750. *   NAME
  2751. *    ScaligerYearToJ -- Returns the Scaliger year as Julian year. (V33)
  2752. *
  2753. *   SYNOPSIS
  2754. *    year = ScaligerYearToJ(syear);
  2755. *     d0            d0
  2756. *
  2757. *    int ScaligerYearToJ(const unsigned int syear);
  2758. *
  2759. *   FUNCTION
  2760. *    Returns the Julian year of a Scaliger year.
  2761. *
  2762. *   INPUTS
  2763. *    syear     - Scaliger year
  2764. *
  2765. *   RESULT
  2766. *    year - The Julian year
  2767. *
  2768. *   EXAMPLE
  2769. *    ...
  2770. *    year = ScaligerYearToJ(4800);
  2771. *    ...
  2772. *
  2773. *   NOTES
  2774. *    It is better to use this function only from 4707 to 6295!
  2775. *
  2776. *   BUGS
  2777. *    unknown.
  2778. *
  2779. *   SEE ALSO
  2780. *    ScaligerYearToG(),ScaligerYearToH()
  2781. *
  2782. *****************************************************************************
  2783. *
  2784. *
  2785. */
  2786.  
  2787.  {if (syear < 4714)
  2788.     return((int)(4714+syear));
  2789.   else
  2790.     return((int)(syear-4713));
  2791.  }
  2792.  
  2793.  
  2794.  #ifdef __MakeLib
  2795.    int __saveds __asm ScaligerYearToG(register __d0 const unsigned int syear)
  2796.  #else
  2797.    int ScaligerYearToG(const unsigned int syear)
  2798.  #endif
  2799.  
  2800. /*
  2801. ******* Date/ScaligerYearToG ************************************************
  2802. *
  2803. *   NAME
  2804. *    ScaligerYearToG -- Returns the Scaliger year as Gregorian year. (V33)
  2805. *
  2806. *   SYNOPSIS
  2807. *    year = ScaligerYearToG(syear);
  2808. *     d0            d0
  2809. *
  2810. *    int ScaligerYearToG(const unsigned int syear);
  2811. *
  2812. *   FUNCTION
  2813. *    Returns the Gregorian year of a Scaliger year.
  2814. *
  2815. *   INPUTS
  2816. *    syear     - Scaliger year
  2817. *
  2818. *   RESULT
  2819. *    year - The Gregorian year
  2820. *
  2821. *   EXAMPLE
  2822. *    ...
  2823. *    year = ScaligerYearToG(6400);
  2824. *    ...
  2825. *
  2826. *   NOTES
  2827. *    It is better to use this function only from 4707 to 7981!
  2828. *
  2829. *   BUGS
  2830. *    unknown.
  2831. *
  2832. *   SEE ALSO
  2833. *    ScaligerYearToJ(),ScaligerYearToH()
  2834. *
  2835. *****************************************************************************
  2836. *
  2837. *
  2838. */
  2839.  
  2840.  {return(ScaligerYearToJ(syear));
  2841.  }
  2842.  
  2843.  
  2844.  #ifdef __MakeLib
  2845.    int __saveds __asm ScaligerYearToH(register __d0 const unsigned int syear)
  2846.  #else
  2847.    int ScaligerYearToH(const unsigned int syear)
  2848.  #endif
  2849.  
  2850. /*
  2851. ******* Date/ScaligerYearToH ************************************************
  2852. *
  2853. *   NAME
  2854. *    ScaligerYearToH -- Returns the Scaliger year as Heis year. (V33)
  2855. *
  2856. *   SYNOPSIS
  2857. *    year = ScaligerYearToH(syear);
  2858. *     d0            d0
  2859. *
  2860. *    int ScaligerYearToH(const unsigned int syear);
  2861. *
  2862. *   FUNCTION
  2863. *    Returns the Heis year of a Scaliger year.
  2864. *
  2865. *   INPUTS
  2866. *    syear     - Scaliger year
  2867. *
  2868. *   RESULT
  2869. *    year - The Heis year
  2870. *
  2871. *   EXAMPLE
  2872. *    ...
  2873. *    year = ScaligerYearToH(7000);
  2874. *    ...
  2875. *
  2876. *   NOTES
  2877. *    It is better to use this function only from 4707 to 7981!
  2878. *
  2879. *   BUGS
  2880. *    unknown.
  2881. *
  2882. *   SEE ALSO
  2883. *    ScaligerYearToJ(),ScaligerYearToG()
  2884. *
  2885. *****************************************************************************
  2886. *
  2887. *
  2888. */
  2889.  
  2890.  {/* for compatibilitie if ScaligerYearToG is changed! */
  2891.   return(ScaligerYearToG(syear));
  2892.  }
  2893.  
  2894.  /* ----------------------------------------------------------------------- */
  2895.  
  2896.  #ifdef __MakeLib
  2897.    unsigned long __saveds __asm JSYearToJD(register __d0 const unsigned int syear)
  2898.  #else
  2899.    unsigned long JSYearToJD(const unsigned int syear)
  2900.  #endif
  2901.  
  2902. /*
  2903. ******* Date/JSYearToJD *****************************************************
  2904. *
  2905. *   NAME
  2906. *    JSYearToJD -- Calcs the JD from a Scaliger year. (V33)
  2907. *
  2908. *   SYNOPSIS
  2909. *    jd = JSYearToJD(syear);
  2910. *    d0         d0
  2911. *
  2912. *    unsigned long JSYearToJD(const unsigned int syear);
  2913. *
  2914. *   FUNCTION
  2915. *    Returns the Julianday of a Scaliger year.
  2916. *
  2917. *   INPUTS
  2918. *    syear     - Scaliger year
  2919. *
  2920. *   RESULT
  2921. *    jd - The Julianday
  2922. *
  2923. *   EXAMPLE
  2924. *    ...
  2925. *    jd = JSYearToJD(4800);
  2926. *    ...
  2927. *
  2928. *   NOTES
  2929. *    It is better to use this function only from 4707 to 6295!
  2930. *
  2931. *   BUGS
  2932. *    unknown.
  2933. *
  2934. *   SEE ALSO
  2935. *    GSYearToJD(),HSYearToJD()
  2936. *
  2937. *****************************************************************************
  2938. *
  2939. *
  2940. */
  2941.  
  2942.  {return(((unsigned long)syear-1)*365+((unsigned long)syear+2) / 4);
  2943.  }
  2944.  
  2945.  
  2946.  #ifdef __MakeLib
  2947.    unsigned long __saveds __asm GSYearToJD(register __d0 const unsigned int syear)
  2948.  #else
  2949.    unsigned long GSYearToJD(const unsigned int syear)
  2950.  #endif
  2951.  
  2952. /*
  2953. ******* Date/GSYearToJD *****************************************************
  2954. *
  2955. *   NAME
  2956. *    GSYearToJD -- Calcs the JD from a Scaliger year. (V33)
  2957. *
  2958. *   SYNOPSIS
  2959. *    jd = GSYearToJD(syear);
  2960. *    d0         d0
  2961. *
  2962. *    unsigned long GSYearToJD(const unsigned int syear);
  2963. *
  2964. *   FUNCTION
  2965. *    Returns the Julianday of a Scaliger year.
  2966. *
  2967. *   INPUTS
  2968. *    syear     - Scaliger year
  2969. *
  2970. *   RESULT
  2971. *    jd - The Julianday
  2972. *
  2973. *   EXAMPLE
  2974. *    ...
  2975. *    jd = GSYearToJD(4800);
  2976. *    ...
  2977. *
  2978. *   NOTES
  2979. *    It is better to use this function only from 4707 to 7981!
  2980. *
  2981. *   BUGS
  2982. *    unknown.
  2983. *
  2984. *   SEE ALSO
  2985. *    JSYearToJD(),HSYearToJD()
  2986. *
  2987. *****************************************************************************
  2988. *
  2989. *
  2990. */
  2991.  
  2992.  {if (syear < 6296)
  2993.     {/* 1583 */
  2994.      return(JSYearToJD(syear));
  2995.     }
  2996.   else
  2997.     return(JSYearToJD(6296)-10+(unsigned long)(GregorianDayDiff(1,1,1583,1,1,ScaligerYearToG(syear))));
  2998.  }
  2999.  
  3000.  
  3001.  #ifdef __MakeLib
  3002.    unsigned long __saveds __asm HSYearToJD(register __d0 const unsigned int syear)
  3003.  #else
  3004.    unsigned long HSYearToJD(const unsigned int syear)
  3005.  #endif
  3006.  
  3007. /*
  3008. ******* Date/HSYearToJD *****************************************************
  3009. *
  3010. *   NAME
  3011. *    HSYearToJD -- Calcs the JD from a Scaliger year. (V33)
  3012. *
  3013. *   SYNOPSIS
  3014. *    jd = HSYearToJD(syear);
  3015. *    d0         d0
  3016. *
  3017. *    unsigned long HSYearToJD(const unsigned int syear);
  3018. *
  3019. *   FUNCTION
  3020. *    Returns the Julianday of a Scaliger year.
  3021. *
  3022. *   INPUTS
  3023. *    syear     - Scaliger year
  3024. *
  3025. *   RESULT
  3026. *    jd - The Julianday
  3027. *
  3028. *   EXAMPLE
  3029. *    ...
  3030. *    jd = HSYearToJD(6700);
  3031. *    ...
  3032. *
  3033. *   NOTES
  3034. *    It is better to use this function only from 4707 to 7981!
  3035. *    In this version only GSYearToJD() is called, because the
  3036. *    Scaliger period is only valid to 3268
  3037. *
  3038. *   BUGS
  3039. *    unknown.
  3040. *
  3041. *   SEE ALSO
  3042. *    JSYearToJD(),GSYearToJD()
  3043. *
  3044. *****************************************************************************
  3045. *
  3046. *
  3047. */
  3048.  
  3049.  {/* for compatibilitie if GSYearToJD is changed! */
  3050.   return(GSYearToJD(syear));
  3051.  }
  3052.  
  3053.  /* ----------------------------------------------------------------------- */
  3054.  
  3055.  #ifdef __MakeLib
  3056.    unsigned long __saveds __asm JDtoMJD(register __d0 const unsigned long jd)
  3057.  #else
  3058.    unsigned long JDtoMJD(const unsigned long jd)
  3059.  #endif
  3060.  
  3061. /*
  3062. ******* Date/JDtoMJD ********************************************************
  3063. *
  3064. *   NAME
  3065. *    JDtoMJD -- Switches from JD to MJD. (V33)
  3066. *
  3067. *   SYNOPSIS
  3068. *    mjd = JDtoMJD(jd);
  3069. *    d0          d0
  3070. *
  3071. *    unsigned long JDtoMJD(const unsigned long jd);
  3072. *
  3073. *   FUNCTION
  3074. *    Returns the Modified Julianday of a Julianday.
  3075. *
  3076. *   INPUTS
  3077. *    jd - Julianday
  3078. *
  3079. *   RESULT
  3080. *    mjd - The Modified Julianday
  3081. *
  3082. *   EXAMPLE
  3083. *    ...
  3084. *    mjd = JDtoMJD(2449354);
  3085. *    ...
  3086. *
  3087. *   NOTES
  3088. *    none
  3089. *
  3090. *   BUGS
  3091. *    Only use this function for jd > 2400001, because mjd is only
  3092. *    defined for this, otherwise system will crash!
  3093. *
  3094. *   SEE ALSO
  3095. *    MJDtoJD()
  3096. *
  3097. *****************************************************************************
  3098. *
  3099. *
  3100. */
  3101.  
  3102.  {return(jd-2400001L);
  3103.  }
  3104.  
  3105.  
  3106.  #ifdef __MakeLib
  3107.    unsigned long __saveds __asm MJDtoJD(register __d0 const unsigned long mjd)
  3108.  #else
  3109.    unsigned long MJDtoJD(const unsigned long mjd)
  3110.  #endif
  3111.  
  3112. /*
  3113. ******* Date/MJDtoJD ********************************************************
  3114. *
  3115. *   NAME
  3116. *    MJDtoJD -- Switches from MJD to JD. (V33)
  3117. *
  3118. *   SYNOPSIS
  3119. *    jd = MJDtoJD(mjd);
  3120. *    d0         d0
  3121. *
  3122. *    unsigned long MJDtoJD(const unsigned long mjd);
  3123. *
  3124. *   FUNCTION
  3125. *    Returns the Julianday of a Modified Julianday.
  3126. *
  3127. *   INPUTS
  3128. *    mjd - Modified Julianday
  3129. *
  3130. *   RESULT
  3131. *    jd - The Julianday
  3132. *
  3133. *   EXAMPLE
  3134. *    ...
  3135. *    jd = JDtoMJD(49353);
  3136. *    ...
  3137. *
  3138. *   NOTES
  3139. *    none
  3140. *
  3141. *   BUGS
  3142. *    unknown.
  3143. *
  3144. *   SEE ALSO
  3145. *    MJDtoJD()
  3146. *
  3147. *****************************************************************************
  3148. *
  3149. *
  3150. */
  3151.  
  3152.  {return(mjd+2400001L);
  3153.  }
  3154.  
  3155.  /* ----------------------------------------------------------------------- */
  3156.  
  3157.  #ifdef __MakeLib
  3158.    unsigned long __saveds __asm JulianToJD(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year)
  3159.  #else
  3160.    unsigned long JulianToJD(const unsigned short day, const unsigned short month, const int year)
  3161.  #endif
  3162.  
  3163. /*
  3164. ******* Date/JulianToJD *****************************************************
  3165. *
  3166. *   NAME
  3167. *    JulianToJD -- Returns the JD for a date. (V33)
  3168. *
  3169. *   SYNOPSIS
  3170. *    jd = JulianToJD(day,month,year);
  3171. *    d0        d0   d1    d2
  3172. *
  3173. *    unsigned long JulianToJD(const unsigned short day,
  3174. *        const unsigned short month, const int year);
  3175. *
  3176. *   FUNCTION
  3177. *    Returns the JD for a Julian date.
  3178. *
  3179. *   INPUTS
  3180. *    day      - day of the date to convert
  3181. *    month    - month of the date to convert
  3182. *    year     - year of the date to convert
  3183. *
  3184. *   RESULT
  3185. *    jd - This is the JD
  3186. *
  3187. *   EXAMPLE
  3188. *    ...
  3189. *    jd = JulianToJD(23,1,1994);
  3190. *    ...
  3191. *
  3192. *   NOTES
  3193. *    It is better to use this function only from -7 to 1582!
  3194. *
  3195. *   BUGS
  3196. *    unknown.
  3197. *
  3198. *   SEE ALSO
  3199. *    JSYearToJD(),JYearToScaliger(),JulianDayDiff(),GregorianToJD(),
  3200. *    HeisToJD()
  3201. *
  3202. *****************************************************************************
  3203. *
  3204. *
  3205. */
  3206.  
  3207.  {return(JSYearToJD(JYearToScaliger(year))+(unsigned long)(JulianDayDiff(1,1,year,day,month,year)));
  3208.  }
  3209.  
  3210.  
  3211.  #ifdef __MakeLib
  3212.    unsigned long __saveds __asm GregorianToJD(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year)
  3213.  #else
  3214.    unsigned long GregorianToJD(const unsigned short day, const unsigned short month, const int year)
  3215.  #endif
  3216.  
  3217. /*
  3218. ******* Date/GregorianToJD **************************************************
  3219. *
  3220. *   NAME
  3221. *    GregorianToJD -- Returns the JD for a date. (V33)
  3222. *
  3223. *   SYNOPSIS
  3224. *    jd = GregorianToJD(day,month,year);
  3225. *    d0           d0   d1    d2
  3226. *
  3227. *    unsigned long GregorianToJD(const unsigned short day,
  3228. *        const unsigned short month, const int year);
  3229. *
  3230. *   FUNCTION
  3231. *    Returns the JD for a Gregorian date.
  3232. *
  3233. *   INPUTS
  3234. *    day      - day of the date to convert
  3235. *    month    - month of the date to convert
  3236. *    year     - year of the date to convert
  3237. *
  3238. *   RESULT
  3239. *    jd - This is the JD
  3240. *
  3241. *   EXAMPLE
  3242. *    ...
  3243. *    jd = GregorianToJD(23,1,1994);
  3244. *    ...
  3245. *
  3246. *   NOTES
  3247. *    It is better to use this function only from -7 to 3200!
  3248. *
  3249. *   BUGS
  3250. *    unknown.
  3251. *
  3252. *   SEE ALSO
  3253. *    GSYearToJD(),GYearToScaliger(),GregorianDayDiff(),JulianToJD(),
  3254. *    HeisToJD()
  3255. *
  3256. *****************************************************************************
  3257. *
  3258. *
  3259. */
  3260.  
  3261.  {return(GSYearToJD(GYearToScaliger(year))+(unsigned long)(GregorianDayDiff(1,1,year,day,month,year)));
  3262.  }
  3263.  
  3264.  
  3265.  #ifdef __MakeLib
  3266.    unsigned long __saveds __asm HeisToJD(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year)
  3267.  #else
  3268.    unsigned long HeisToJD(const unsigned short day, const unsigned short month, const int year)
  3269.  #endif
  3270.  
  3271. /*
  3272. ******* Date/HeisToJD *******************************************************
  3273. *
  3274. *   NAME
  3275. *    HeisToJD -- Returns the JD for a date. (V33)
  3276. *
  3277. *   SYNOPSIS
  3278. *    jd = HeisToJD(day,month,year);
  3279. *    d0          d0   d1    d2
  3280. *
  3281. *    unsigned long HeisToJD(const unsigned short day,
  3282. *        const unsigned short month, const int year);
  3283. *
  3284. *   FUNCTION
  3285. *    Returns the JD for a Heis date.
  3286. *
  3287. *   INPUTS
  3288. *    day      - day of the date to convert
  3289. *    month    - month of the date to convert
  3290. *    year     - year of the date to convert
  3291. *
  3292. *   RESULT
  3293. *    jd - This is the JD
  3294. *
  3295. *   EXAMPLE
  3296. *    ...
  3297. *    jd = HeisToJD(23,1,1994);
  3298. *    ...
  3299. *
  3300. *   NOTES
  3301. *    It is better to use this function only from -7 to 3268!
  3302. *
  3303. *   BUGS
  3304. *    unknown.
  3305. *
  3306. *   SEE ALSO
  3307. *    HSYearToJD(),HYearToScaliger(),HeisDayDiff(),JulianToJD(),HeisToJD()
  3308. *
  3309. *****************************************************************************
  3310. *
  3311. *
  3312. */
  3313.  
  3314.  {return(HSYearToJD(HYearToScaliger(year))+(unsigned long)(HeisDayDiff(1,1,year,day,month,year)));
  3315.  }
  3316.  
  3317.  /* ----------------------------------------------------------------------- */
  3318.  
  3319.  #ifdef __MakeLib
  3320.    float __saveds __asm TimeToJD(register __d0 const unsigned short hour, register __d1 const unsigned short min, register __d2 const unsigned short sec)
  3321.  #else
  3322.    float TimeToJD(const unsigned short hour, const unsigned short min, const unsigned short sec)
  3323.  #endif
  3324.  
  3325. /*
  3326. ******* Date/TimeToJD *******************************************************
  3327. *
  3328. *   NAME
  3329. *    TimeToJD -- Returns the JD for a time. (V33)
  3330. *
  3331. *   SYNOPSIS
  3332. *    jd = TimeToJD(hour,min,sec);
  3333. *    d0           d0   d1  d2
  3334. *
  3335. *    float TimeToJD(const unsigned short hour, const unsigned short min,
  3336. *        const unsigned short sec);
  3337. *
  3338. *   FUNCTION
  3339. *    Returns the JD for a specified time.
  3340. *
  3341. *   INPUTS
  3342. *    hour - hour of the time to convert
  3343. *    min  - minute of the time to convert
  3344. *    sec  - sec. of the time to convert
  3345. *
  3346. *   RESULT
  3347. *    jd - This is the JD time
  3348. *
  3349. *   EXAMPLE
  3350. *    ...
  3351. *    jd = TimeToJD(16,33,0);
  3352. *    ...
  3353. *
  3354. *   NOTES
  3355. *    none
  3356. *
  3357. *   BUGS
  3358. *    There is no check, if the specified time is a valid time!
  3359. *
  3360. *   SEE ALSO
  3361. *    JDToTime()
  3362. *
  3363. *****************************************************************************
  3364. *
  3365. *
  3366. */
  3367.  
  3368.  {return((float)(((unsigned long)hour*3600+(unsigned int)min*60+sec) / 86400.0));
  3369.  }
  3370.  
  3371.  
  3372.  #ifdef __MakeLib
  3373.    void __saveds __asm JDToTime(register __d0 float jd, register __a0 unsigned short *rhour, register __a1 unsigned short *rmin, register __a2 unsigned short *rsec)
  3374.  #else
  3375.    void JDToTime(float jd, unsigned short *rhour, unsigned short *rmin, unsigned short *rsec)
  3376.  #endif
  3377.  
  3378. /*
  3379. ******* Date/JDToTime *******************************************************
  3380. *
  3381. *   NAME
  3382. *    JDToTime -- Returns the real time for a JD time. (V33)
  3383. *
  3384. *   SYNOPSIS
  3385. *    JDToTime(jd,rhour,rmin,rsec);
  3386. *         d0  a0    a1   a2
  3387. *
  3388. *    void JDToTime(float jd, unsigned short *rhour, unsigned short *rmin,
  3389. *        unsigned short *rsec);
  3390. *
  3391. *   FUNCTION
  3392. *    Returns the real time for a JD time.
  3393. *
  3394. *   INPUTS
  3395. *    jd - JD time
  3396. *
  3397. *   RESULT
  3398. *    rhour - 24 hour real time
  3399. *    rmin  - real minutes
  3400. *    rsec  - real seconds
  3401. *
  3402. *   EXAMPLE
  3403. *    ...
  3404. *    JDToTime(0.76543,&rhour,&rmin,&rsec);
  3405. *    ...
  3406. *
  3407. *   NOTES
  3408. *    none.
  3409. *
  3410. *   BUGS
  3411. *    If jd is > 0 (including days) there will be occur arithmetic bugs!
  3412. *
  3413. *   SEE ALSO
  3414. *    TimeToJD()
  3415. *
  3416. *****************************************************************************
  3417. *
  3418. *
  3419. */
  3420.  
  3421.  {unsigned long sec;
  3422.  
  3423.   if (jd > 0.0)
  3424.     jd -= floor(jd);
  3425.   sec = (unsigned long)(jd * 86400.0);
  3426.   *rhour = (unsigned short)(sec / 3600);
  3427.   sec -= (*rhour) * 3600;
  3428.   *rmin = (unsigned short)(sec / 60);
  3429.   sec -= (*rmin) * 60;
  3430.   *rsec = (unsigned short)sec;
  3431.  }
  3432.  
  3433.  /* ----internal----------------------------------------------------------- */
  3434.  
  3435.  static unsigned short GregorianSZ(const unsigned int year)
  3436.  
  3437. /*
  3438. *****i* Date/GregorianSZ ****************************************************
  3439. *
  3440. *   NAME
  3441. *    GregorianSZ -- Returns the 'Sonnenzirkel' (V33)
  3442. *
  3443. *   SYNOPSIS
  3444. *    sz = GregorianSZ(year);
  3445. *
  3446. *    unsigned short GregorianSZ(const unsigned int year);
  3447. *
  3448. *   FUNCTION
  3449. *    Returns the 'Sonnenzirkel' of a year.
  3450. *
  3451. *   INPUTS
  3452. *    year     - For this year the 'Sonnenzirkel' is calculatet.
  3453. *
  3454. *   RESULT
  3455. *    sz - The 'Sonnenzirkel' for the specified year.
  3456. *
  3457. *   EXAMPLE
  3458. *    ...
  3459. *    sz = GregorianSZ(1994);
  3460. *    ...
  3461. *
  3462. *   NOTES
  3463. *    Use this only for 1582 to 4100!
  3464. *
  3465. *   BUGS
  3466. *    unknown.
  3467. *
  3468. *   SEE ALSO
  3469. *    GYearToScaliger()
  3470. *
  3471. *****************************************************************************
  3472. *
  3473. *
  3474. */
  3475.  
  3476.  {unsigned short gz;
  3477.   gz = (unsigned short)(GYearToScaliger(year) % 28);
  3478.   if (gz==0)
  3479.     gz = 28;
  3480.   return(gz);
  3481.  }
  3482.  
  3483.  
  3484.  static unsigned short GregorianGZ(const unsigned int year)
  3485.  
  3486. /*
  3487. *****i* Date/GregorianGZ ****************************************************
  3488. *
  3489. *   NAME
  3490. *    GregorianGZ -- Returns the 'Goldene Zahl' (golden number) (V33)
  3491. *
  3492. *   SYNOPSIS
  3493. *    gz = GregorianGZ(year);
  3494. *
  3495. *    unsigned short GregorianGZ(const unsigned int year);
  3496. *
  3497. *   FUNCTION
  3498. *    Returns the 'Goldene Zahl' of a year.
  3499. *
  3500. *   INPUTS
  3501. *    year     - For this year the 'Goldene Zahl' is calculatet.
  3502. *
  3503. *   RESULT
  3504. *    gz - The 'Goldene Zahl' for the specified year.
  3505. *
  3506. *   EXAMPLE
  3507. *    ...
  3508. *    gz = GregorianGZ(1994);
  3509. *    ...
  3510. *
  3511. *   NOTES
  3512. *    Use this only for 1582 to 4100!
  3513. *
  3514. *   BUGS
  3515. *    unknown.
  3516. *
  3517. *   SEE ALSO
  3518. *    GYearToScaliger()
  3519. *
  3520. *****************************************************************************
  3521. *
  3522. *
  3523. */
  3524.  
  3525.  {unsigned int syear;
  3526.  
  3527.   syear = GYearToScaliger(year) % 19;
  3528.   if (syear == 0)
  3529.     syear = 19;
  3530.   return((unsigned short)syear);
  3531.  }
  3532.  
  3533.  
  3534.  static unsigned short GEP(const unsigned int year)
  3535.  
  3536. /*
  3537. *****i* Date/GEP ************************************************************
  3538. *
  3539. *   NAME
  3540. *    GEP -- Internal function to help calculating the 'EP' (V33)
  3541. *
  3542. *   SYNOPSIS
  3543. *    hep = GEP(year);
  3544. *
  3545. *    unsigned short GEP(const unsigned int year);
  3546. *
  3547. *   FUNCTION
  3548. *    Internal function to help calculating the 'EP'
  3549. *
  3550. *   INPUTS
  3551. *    year - This is the year for which the help EP is to be
  3552. *        calculatetd
  3553. *
  3554. *   RESULT
  3555. *    hep - The help value for the EP calculation.
  3556. *
  3557. *   EXAMPLE
  3558. *    ...
  3559. *    hep = GEP(1994);
  3560. *    ...
  3561. *
  3562. *   NOTES
  3563. *    Use this only for 1582 to 4200!
  3564. *
  3565. *   BUGS
  3566. *    unknown.
  3567. *
  3568. *   SEE ALSO
  3569. *
  3570. *
  3571. *****************************************************************************
  3572. *
  3573. *
  3574. */
  3575.  
  3576.    {unsigned short    century,decade;
  3577.     int            ep;
  3578.  
  3579.     ep = 1; /* 1582 */
  3580.     century = (unsigned short)(year / 100);
  3581.     decade = (unsigned short)(year - century * 100);
  3582.     if (year < 1701)
  3583.       return(1);
  3584.     else
  3585.       if (year < 1800)
  3586.         return(0);
  3587.       else
  3588.         {ep -= (int)(((century) % 4) + (((century-16) / 4) * 3));
  3589.          if ((decade == 0) && ((century % 4) > 0))
  3590.            ep++;
  3591.          ep += (int)((century-18) / 3);
  3592.          if ((((century-18) % 3) > 0) || (decade > 0))
  3593.            ep++;
  3594.          if (ep > 29)
  3595.            ep %= 30;
  3596.          if (ep < 0)
  3597.            ep += 30;
  3598.          return((unsigned short)ep);
  3599.         }
  3600.    }
  3601.  
  3602.  
  3603.  static unsigned short GregorianEP(const unsigned int year)
  3604.  
  3605. /*
  3606. *****i* Date/GregorianEP ****************************************************
  3607. *
  3608. *   NAME
  3609. *    GregorianEP -- Returns the 'Epakte' (V33)
  3610. *
  3611. *   SYNOPSIS
  3612. *    ep = GregorianEP(year);
  3613. *
  3614. *    unsigned short GregorianEP(const unsigned int year);
  3615. *
  3616. *   FUNCTION
  3617. *    Returns the 'Epakte' of a year.
  3618. *
  3619. *   INPUTS
  3620. *    year     - For this year the 'Epakte' is calculatet.
  3621. *
  3622. *   RESULT
  3623. *    ep - The 'Epakte' for the specified year.
  3624. *
  3625. *   EXAMPLE
  3626. *    ...
  3627. *    ep = GregorianEP(1994);
  3628. *    ...
  3629. *
  3630. *   NOTES
  3631. *    Use this only for 1582 to 4100!
  3632. *
  3633. *   BUGS
  3634. *    unknown.
  3635. *
  3636. *   SEE ALSO
  3637. *    GEP(),GregorianGZ()
  3638. *
  3639. *****************************************************************************
  3640. *
  3641. *
  3642. */
  3643.  
  3644.  {unsigned short ep;
  3645.  
  3646.   if (year >= 1582)
  3647.    {
  3648.     ep = (unsigned short)(((GregorianGZ(year)-1)*11 + GEP(year)) % 30);
  3649.     if (ep == 0)
  3650.       ep = 30;
  3651.     return(ep);
  3652.    }
  3653.   else
  3654.     return(31);
  3655.  }
  3656.  
  3657.  
  3658.  static unsigned short GregorianJHStartSB(const unsigned short century)
  3659.  
  3660. /*
  3661. *****i* Date/GregorianJHStartSB *********************************************
  3662. *
  3663. *   NAME
  3664. *    GregorianJHStartSB -- Returns the 'Sonntagsbuchstabe' (V33)
  3665. *
  3666. *   SYNOPSIS
  3667. *    csb = GregorianJHStartSB(century);
  3668. *
  3669. *    unsigned short GregorianJHStartSB(const unsigned short century);
  3670. *
  3671. *   FUNCTION
  3672. *    Returns start 'SB' for a century.
  3673. *
  3674. *   INPUTS
  3675. *    century - For this century the start 'SB' is calculatet.
  3676. *
  3677. *   RESULT
  3678. *    csb - The start 'SB' for the specified century.
  3679. *
  3680. *   EXAMPLE
  3681. *    ...
  3682. *    csb = GregorianJHStartSB(19);
  3683. *    ...
  3684. *
  3685. *   NOTES
  3686. *    Use this only for 15 to 31!
  3687. *
  3688. *   BUGS
  3689. *    unknown.
  3690. *
  3691. *   SEE ALSO
  3692. *    GregorianJHStartSB()
  3693. *
  3694. *****************************************************************************
  3695. *
  3696. *
  3697. */
  3698.  
  3699.  {unsigned short sb;
  3700.  
  3701.   if (century == 15)
  3702.     return(4);
  3703.   else
  3704.    {
  3705.     sb = GregorianJHStartSB(century-1);
  3706.     if ((century % 4) > 0)
  3707.       sb++;
  3708.     sb %= 7;
  3709.     if (sb == 0)
  3710.       sb = 7;
  3711.     return(sb);
  3712.    }
  3713.  }
  3714.  
  3715.  
  3716.  static unsigned short GregorianJHSB(const unsigned int year)
  3717.  
  3718. /*
  3719. *****i* Date/GregorianSB ****************************************************
  3720. *
  3721. *   NAME
  3722. *    GregorianJHSB -- Returns the 'Sonntagsbuchstabe' (V33)
  3723. *
  3724. *   SYNOPSIS
  3725. *    sb = GregorianJHSB(year);
  3726. *
  3727. *    unsigned short GregorianJHSB(const unsigned int year);
  3728. *
  3729. *   FUNCTION
  3730. *    Returns the start 'SB' for a century year.
  3731. *
  3732. *   INPUTS
  3733. *    year - For this century year the start 'SB' is calculatet.
  3734. *
  3735. *   RESULT
  3736. *    sb - The start 'SB' for the specified year.
  3737. *
  3738. *   EXAMPLE
  3739. *    ...
  3740. *    sb = GregorianJHSB(1994);
  3741. *    ...
  3742. *
  3743. *   NOTES
  3744. *    Use this only for 1583 to 3199!
  3745. *
  3746. *   BUGS
  3747. *    unknown.
  3748. *
  3749. *   SEE ALSO
  3750. *    GregorianLeapYear(),GregorianJHStartSB()
  3751. *
  3752. *****************************************************************************
  3753. *
  3754. *
  3755. */
  3756.  
  3757.  {
  3758.   if (((year % 100) == 0) && (!GregorianLeapYear((int)year)))
  3759.     return((unsigned short)(((year / 100) % 4) *2 +1));
  3760.   else
  3761.     return(GregorianJHStartSB(year / 100));
  3762.  }
  3763.  
  3764.  
  3765.  static unsigned short GregorianSB(const unsigned int year)
  3766.  
  3767. /*
  3768. *****i* Date/GregorianSB ****************************************************
  3769. *
  3770. *   NAME
  3771. *    GregorianSB -- Returns the 'Sonntagsbuchstabe' (V33)
  3772. *
  3773. *   SYNOPSIS
  3774. *    sb = GregorianSB(year);
  3775. *
  3776. *    unsigned short GregorianSB(const unsigned int year);
  3777. *
  3778. *   FUNCTION
  3779. *    Returns the 'SB' for a year.
  3780. *
  3781. *   INPUTS
  3782. *    year - For this year the 'SB' is calculatet.
  3783. *
  3784. *   RESULT
  3785. *    sb - The 'SB' for the specified year.
  3786. *        This means the day the first Sunday lies on :)
  3787. *
  3788. *   EXAMPLE
  3789. *    ...
  3790. *    sb = GregorianSB(1994);
  3791. *    ...
  3792. *
  3793. *   NOTES
  3794. *    Use this only for 1583 to 3199!
  3795. *
  3796. *   BUGS
  3797. *    unknown.
  3798. *
  3799. *   SEE ALSO
  3800. *    GregorianLeapYear(),GregorianSZ(),GregorianJHStartSB()
  3801. *
  3802. *****************************************************************************
  3803. *
  3804. *
  3805. */
  3806.  
  3807.  {unsigned short sz,csb,i;
  3808.  
  3809.   if (((year % 100) == 0) && (!GregorianLeapYear((int)year)))
  3810.     return((unsigned short)(((year / 100) % 4) *2 +1));
  3811.   else
  3812.    {
  3813.     sz = GregorianSZ(year);
  3814.     csb = GregorianJHStartSB(year / 100);
  3815.     if (sz == 28)
  3816.       return(csb);
  3817.     else
  3818.      {
  3819.       for (i=27;i>=sz;i--)
  3820.        {
  3821.         csb++;
  3822.         if (csb == 8)
  3823.           csb = 1;
  3824.         if (((i-1) % 4) == 0)
  3825.          {
  3826.           csb++;
  3827.           if (csb == 8)
  3828.             csb =1;
  3829.          }
  3830.        }
  3831.       return(csb);
  3832.      }
  3833.    }
  3834.  }
  3835.  
  3836.  
  3837.  static unsigned short MoonMonthAge(const unsigned short month, unsigned short ep, const int year)
  3838.  
  3839. /*
  3840. *****i* Date/MoonMonthAge ***************************************************
  3841. *
  3842. *   NAME
  3843. *    MoonMonthAge -- Calculates the age of the moon on month start (V33)
  3844. *
  3845. *   SYNOPSIS
  3846. *    ep = MoonMonthAge(month,ep);
  3847. *
  3848. *    unsigned short MoonMonthAge(unsigned short month, unsigned short ep,
  3849. *        const int year);
  3850. *
  3851. *   FUNCTION
  3852. *    Returns the age of the moon on the start of a month.
  3853. *
  3854. *   INPUTS
  3855. *    month - Month for which the moonage is needed.
  3856. *    ep    - 'Epakte' of the newyears-day.
  3857. *
  3858. *   RESULT
  3859. *    ep - The moonage on the 1. of the specified month.
  3860. *
  3861. *   EXAMPLE
  3862. *    ...
  3863. *    ep = MoonMonthAge(2,17); / * 17 is for 1994 * /
  3864. *    ...
  3865. *
  3866. *   NOTES
  3867. *    This is only a experimental version!
  3868. *
  3869. *   BUGS
  3870. *    unknown.
  3871. *
  3872. *   SEE ALSO
  3873. *    MoonMonthAge(),GregorianMonthDays()
  3874. *
  3875. *****************************************************************************
  3876. *
  3877. *
  3878. */
  3879.  
  3880.    {if (month == 1)
  3881.       return(ep);
  3882.     else
  3883.       if (month % 2 == 0)
  3884.         ep = (unsigned short)((MoonMonthAge(month-1,ep,year) + GregorianMonthDays(month-1,year)) % 29);
  3885.       else
  3886.         ep = (unsigned short)((MoonMonthAge(month-1,ep,year) + GregorianMonthDays(month-1,year)) % 30);
  3887.       return(ep);
  3888.    }
  3889.  
  3890.  /* ----------------------------------------------------------------------- */
  3891.  
  3892.  #ifdef __MakeLib
  3893.    unsigned short __saveds __asm GregorianMoonAge(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year)
  3894.  #else
  3895.    unsigned short GregorianMoonAge(const unsigned short day, const unsigned short month, const int year)
  3896.  #endif
  3897.  
  3898. /*
  3899. ******* Date/GregorianMoonAge ***********************************************
  3900. *
  3901. *   NAME
  3902. *    GregorianMoonAge -- Returns the age of the moon (V33)
  3903. *
  3904. *   SYNOPSIS
  3905. *    ep = GregorianMoonAge(day,month,year);
  3906. *    d0               d0   d1   d2
  3907. *
  3908. *    unsigned short GregorianMoonAge(const unsigned short day,
  3909. *        const unsigned short month, const int year);
  3910. *
  3911. *   FUNCTION
  3912. *    Returns the age of the moon on a specified date.
  3913. *
  3914. *   INPUTS
  3915. *    day   - For this day the age is calculated.
  3916. *    month - For this month the age is calculated.
  3917. *    year  - For this year the age is calculated.
  3918. *
  3919. *   RESULT
  3920. *    ep - The age of the moon on the specified date.
  3921. *
  3922. *   EXAMPLE
  3923. *    ...
  3924. *    ep = GregorianMoonAge(18,9,1994);
  3925. *    ...
  3926. *
  3927. *   NOTES
  3928. *    Use this only for 1582 to 4100!
  3929. *    This is only a experimental version!
  3930. *
  3931. *   BUGS
  3932. *    unknown.
  3933. *
  3934. *   SEE ALSO
  3935. *    MoonMonthAge(),GregorianEP()
  3936. *
  3937. *****************************************************************************
  3938. *
  3939. *
  3940. */
  3941.  
  3942.  {unsigned short ep;
  3943.  
  3944.   ep = GregorianEP(year);
  3945.   ep = MoonMonthAge(month,ep,year);
  3946.   ep += day -1;
  3947.   if (month > 1)
  3948.     if (month % 2 == 0)
  3949.       {ep %= 30;
  3950.        if (ep == 0)
  3951.          ep = 30;
  3952.       }
  3953.     else
  3954.       {ep %= 29;
  3955.        if (ep == 0)
  3956.          ep = 29;
  3957.       }
  3958.   else
  3959.     if (ep > 29)
  3960.       ep %= 29;
  3961.   return(ep);
  3962.  }
  3963.  
  3964. /*
  3965.  void GregorianEasterOld(const int year, unsigned short *dday, unsigned short *dmonth)
  3966.  
  3967. / *
  3968. *****i* Date/GregorianEasterOld ********************************************
  3969. *
  3970. *   NAME
  3971. *    GregorianEasterOld -- Returns the date of eastern in a year (V33)
  3972. *
  3973. *   SYNOPSIS
  3974. *    GregorianEasterOld(year,dday,dmonth);
  3975. *
  3976. *    void GregorianEasterOld(const int year, unsigned short *dday,
  3977. *        unsigned short *dmonth);
  3978. *
  3979. *   FUNCTION
  3980. *    Returns the date of eastern for a specified year.
  3981. *
  3982. *   INPUTS
  3983. *    year  - eastern is calculated for this year
  3984. *
  3985. *   RESULT
  3986. *    dday   - day of easter-Sunday
  3987. *    dmonth - month of easter-Sunday
  3988. *
  3989. *   EXAMPLE
  3990. *    ...
  3991. *    GregorianEasterOld(1994,&dday,&dmonth);
  3992. *    ...
  3993. *
  3994. *   NOTES
  3995. *    Use this only for 1582 to 4100!
  3996. *    This is only a experimental version!
  3997. *
  3998. *   BUGS
  3999. *    In some years eastern lies one week behind!
  4000. *
  4001. *   SEE ALSO
  4002. *    GregorianMoonAge(),GregorianEP(),GregorianDaysAfterWeekday()
  4003. *
  4004. *****************************************************************************
  4005. *
  4006. *
  4007. * /
  4008.  
  4009.  {unsigned short ep;
  4010.  
  4011.   *dday = 21;
  4012.   *dmonth = 3;
  4013.   ep = GregorianMoonAge(21,3,year);
  4014.   if (ep < 14)
  4015.     *dday += (14-ep);
  4016.   else
  4017.     *dday += (29-ep) + 13;
  4018.   if ((*dday) > 31)
  4019.     {*dday -= 31;
  4020.      (*dmonth)++;
  4021.     }
  4022.   *dday += GregorianDaysAfterWeekday(*dday,*dmonth,year,Sunday);
  4023.   if ((*dday) > 31)
  4024.     {*dday -= 31;
  4025.      (*dmonth)++;
  4026.     }
  4027.  }
  4028. */
  4029.  
  4030.  
  4031.  #ifdef __MakeLib
  4032.    void __saveds __asm GregorianEaster(register __d0 const int year, register __a0 unsigned short *dday, register __a1 unsigned short *dmonth)
  4033.  #else
  4034.    void GregorianEaster(const int year, unsigned short *dday, unsigned short *dmonth)
  4035.  #endif
  4036.  
  4037. /*
  4038. ******* Date/GregorianEaster ************************************************
  4039. *
  4040. *   NAME
  4041. *    GregorianEaster -- Returns the date of eastern in a year (V33)
  4042. *
  4043. *   SYNOPSIS
  4044. *    GregorianEaster(year,dday,dmonth);
  4045. *             d0   a0    a1
  4046. *
  4047. *    void GregorianEaster(const int year, unsigned short *dday,
  4048. *        unsigned short *dmonth);
  4049. *
  4050. *   FUNCTION
  4051. *    Returns the date of eastern for a specified year.
  4052. *
  4053. *   INPUTS
  4054. *    year  - eastern is calculated for this year
  4055. *
  4056. *   RESULT
  4057. *    dday   - day of easter-Sunday
  4058. *    dmonth - month of easter-Sunday
  4059. *
  4060. *   EXAMPLE
  4061. *    ...
  4062. *    GregorianEaster(1994,&dday,&dmonth);
  4063. *    ...
  4064. *
  4065. *   NOTES
  4066. *    Use this only for 1900 to 2099!
  4067. *    Tested for 1977-1994! But this formula is from Gauß - so it must be
  4068. *    correct :) but extended by me (hope this will be a good thing too!)
  4069. *
  4070. *   BUGS
  4071. *    None.
  4072. *
  4073. *   SEE ALSO
  4074. *    GEP(),GregorianJHSB()
  4075. *
  4076. *****************************************************************************
  4077. *
  4078. *
  4079. */
  4080.  
  4081.  {unsigned short a,d,e,f;
  4082.   short M,N;
  4083.  
  4084.   M = (short)((30 - GEP(year)) - 7);
  4085.   if (M < 0)
  4086.     M += 30;
  4087.   N = (short)(GregorianJHSB(year)-2);
  4088.   if (N<1)
  4089.     N += 7;
  4090.   a = (unsigned short)(year % 19);
  4091.   d = (unsigned short)((19*(unsigned int)a+M) % 30);
  4092.   e = (unsigned short)((2*(unsigned int)(year % 4)+4*(unsigned int)(year % 7)+6*(unsigned int)(d)+N) % 7);
  4093.   f = (unsigned short)(d+e);
  4094.  
  4095.   if (f < 10)
  4096.    {/* märz */
  4097.     *dmonth = 3;
  4098.     *dday = (unsigned short)(22+f);
  4099.    }
  4100.   else
  4101.    {/* april */
  4102.     *dmonth = 4;
  4103.     *dday = (unsigned short)(f-9);
  4104.     if (*dday==26)
  4105.       *dday = 19;
  4106.     else
  4107.       if ((*dday==25) && (d==28) && (a>10))
  4108.         *dday = 18;
  4109.    }
  4110.  }
  4111.  
  4112.  /* ----------------------------------------------------------------------- */
  4113.  
  4114.  #ifdef __MakeLib
  4115.    short __saveds __asm TimeZoneFactor(register __d0 const short degree)
  4116.  #else
  4117.    short TimeZoneFactor(const short degree)
  4118.  #endif
  4119.  
  4120. /*
  4121. ******* Date/TimeZoneFactor *************************************************
  4122. *
  4123. *   NAME
  4124. *    TimeZoneFactor -- Returns the value you have to add to GMT time (V33)
  4125. *
  4126. *   SYNOPSIS
  4127. *    addhours = TimeZoneFactor(degrees);
  4128. *       d0                d0
  4129. *
  4130. *    short TimeZoneFactor(const short degree);
  4131. *
  4132. *   FUNCTION
  4133. *    This gives you the hours you have to add to GMT time,
  4134. *    specified on the fact, that a timezone is 15 degrees
  4135. *    and that GMT is centered on 0 degrees!
  4136. *
  4137. *   INPUTS
  4138. *    degrees - Position of timezone you live in
  4139. *    (from -180 east to +180 west)
  4140. *
  4141. *   RESULT
  4142. *    addhours - Time to add to GMT time to get your locale zone time
  4143. *        (-12 to +12)
  4144. *
  4145. *   EXAMPLE
  4146. *    ...
  4147. *    addhours = TimeZoneFactor(-8);
  4148. *    ...
  4149. *
  4150. *   NOTES
  4151. *    none
  4152. *
  4153. *   BUGS
  4154. *    No errorcheck, if you put in valid degrees (-180 to +180)
  4155. *    Only full degrees are supportet, keep sure that you
  4156. *    round in the right way for 0.x degree places
  4157. *    I am not sure about the correct +/- behaviour!!!
  4158. *
  4159. *   SEE ALSO
  4160. *
  4161. *
  4162. *****************************************************************************
  4163. *
  4164. *
  4165. */
  4166.  
  4167.  {if (degree >= 0)
  4168.     return((short)(degree / 15.0 + 0.5));
  4169.   else
  4170.     return((short)(degree / 15.0 - 0.5));
  4171.  }
  4172.  
  4173.  
  4174.  #ifdef __MakeLib
  4175.    long __saveds __asm LMT(register __d0 const unsigned long secs, register __d1 const float meridiandegree, register __d2 const float posdegree)
  4176.  #else
  4177.    long LMT(const unsigned long secs, const float meridiandegree, const float posdegree)
  4178.  #endif
  4179.  
  4180. /*
  4181. ******* Date/LMT ************************************************************
  4182. *
  4183. *   NAME
  4184. *    LMT -- Calculates your local time in your timezone (V33)
  4185. *
  4186. *   SYNOPSIS
  4187. *    secs = LMT(secs,meridian,pos);
  4188. *     d0        d0     d1    d2
  4189. *
  4190. *    unsigned long LMT(const unsigned long secs,
  4191. *        const float meridiandegree, const float posdegree);
  4192. *
  4193. *   FUNCTION
  4194. *    Calculates your Local Mean Time of your place!
  4195. *
  4196. *   INPUTS
  4197. *    secs     - Seconds of the running day (hours*3600+min*60+sec)
  4198. *    meridian - Degrees of your timezone-meridian
  4199. *    pos      - Degrees of your place
  4200. *
  4201. *   RESULT
  4202. *    secs - Local seconds of the running day
  4203. *
  4204. *   EXAMPLE
  4205. *    ...
  4206. *    secs = LMT(76080,-15.0,-8.923055556);
  4207. *    ...
  4208. *
  4209. *   NOTES
  4210. *    none
  4211. *
  4212. *   BUGS
  4213. *    No errorcheck, if you put in valid degrees (-180 to +180)
  4214. *
  4215. *   SEE ALSO
  4216. *
  4217. *
  4218. *****************************************************************************
  4219. *
  4220. *
  4221. */
  4222.  
  4223.  {return((long)secs + (long)((meridiandegree / 15.0 - posdegree / 15.0)*3600.0));
  4224.  }
  4225.  
  4226.  
  4227.  #ifdef __MakeLib
  4228.    unsigned long __saveds __asm TimeToSec(register __d0 const unsigned short hour, register __d1 const unsigned short min, register __d2 const unsigned short sec)
  4229.  #else
  4230.    unsigned long TimeToSec(const unsigned short hour, const unsigned short min, const unsigned short sec)
  4231.  #endif
  4232.  
  4233. /*
  4234. ******* Date/TimeToSec ******************************************************
  4235. *
  4236. *   NAME
  4237. *    TimeToSec -- Returns the time in seconds (V33)
  4238. *
  4239. *   SYNOPSIS
  4240. *    secs = TimeToSec(hour,min,sec);
  4241. *     d0          d0   d1  d2
  4242. *
  4243. *    unsigned long TimeToSec(const unsigned short hour,
  4244. *        const unsigned short min, const unsigned short sec);
  4245. *
  4246. *   FUNCTION
  4247. *    Gives you back the time in seconds
  4248. *
  4249. *   INPUTS
  4250. *    hour - hours you want (0-23)
  4251. *    min  - minutes you want (0-59)
  4252. *    sec  - seconds you want (0-59)
  4253. *
  4254. *   RESULT
  4255. *    secs - Time in seconds
  4256. *
  4257. *   EXAMPLE
  4258. *    ...
  4259. *    secs = TimeToSec(21,15,00);
  4260. *    ...
  4261. *
  4262. *   NOTES
  4263. *    Don't forget to convert AM/PM time to 24h time!
  4264. *
  4265. *   BUGS
  4266. *    No errorcheck, if you use a valid time
  4267. *
  4268. *   SEE ALSO
  4269. *    SecToTime()
  4270. *
  4271. *****************************************************************************
  4272. *
  4273. *
  4274. */
  4275.  
  4276.  {return((unsigned long)hour*3600+(unsigned long)min*60+sec);
  4277.  }
  4278.  
  4279.  
  4280.  #ifdef __MakeLib
  4281.    void __saveds __asm SecToTime(register __d0 unsigned long secs, register __a0 unsigned short *hour, register __a1 unsigned short *min, register __a2 unsigned short *sec)
  4282.  #else
  4283.    void SecToTime(unsigned long secs, unsigned short *hour, unsigned short *min, unsigned short *sec)
  4284.  #endif
  4285.  
  4286. /*
  4287. ******* Date/SecToTime ******************************************************
  4288. *
  4289. *   NAME
  4290. *    SecToTime -- Returns the time from seconds (V33)
  4291. *
  4292. *   SYNOPSIS
  4293. *    SecToTime(secs,hour,min,sec);
  4294. *           d0   a0   a1  a2
  4295. *
  4296. *    SecToTime(unsigned long secs, unsigned short *hour,
  4297. *        unsigned short *min, unsigned short *sec);
  4298. *
  4299. *   FUNCTION
  4300. *    Gives you back the time from the specified seconds
  4301. *
  4302. *   INPUTS
  4303. *    secs - Time in seconds
  4304. *
  4305. *   RESULT
  4306. *    hour - hours (0-23)
  4307. *    min  - minutes (0-59)
  4308. *    sec  - seconds (0-59)
  4309. *
  4310. *   EXAMPLE
  4311. *    ...
  4312. *    SecToTime(76860,&hour,&min,&sec);
  4313. *    ...
  4314. *
  4315. *   NOTES
  4316. *    Don't forget to convert 24h time to AM/PM time if needed!
  4317. *
  4318. *   BUGS
  4319. *    No errorcheck, if you use a valid time
  4320. *
  4321. *   SEE ALSO
  4322. *    TimeToSec()
  4323. *
  4324. *****************************************************************************
  4325. *
  4326. *
  4327. */
  4328.  
  4329.  {*hour = (unsigned short)(secs / 3600);
  4330.   secs -= (unsigned long)(*hour) * 3600;
  4331.   *min = (unsigned short)(secs / 60);
  4332.   *sec = (unsigned short)(secs - (unsigned long)(*min) * 60);
  4333.  }
  4334.  
  4335.  /* ----------------------------------------------------------------------- */
  4336.  
  4337.  #ifdef __MakeLib
  4338.    unsigned short __saveds __asm JulianWeek(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year)
  4339.  #else
  4340.    unsigned short JulianWeek(const unsigned short day, const unsigned short month, const int year)
  4341.  #endif
  4342.  
  4343. /*
  4344. ******* Date/JulianWeek *****************************************************
  4345. *
  4346. *   NAME
  4347. *    JulianWeek -- Gets the weeknumber of a specified date. (V33)
  4348. *
  4349. *   SYNOPSIS
  4350. *    weeknr = JulianWeek(day,month,year);
  4351. *      d0            d0    d1   d2
  4352. *
  4353. *    unsigned short JulianWeek(const unsigned short day,
  4354. *        const unsigned short month, const int year);
  4355. *
  4356. *   FUNCTION
  4357. *    JulianWeek gets the weeknumber for a specified date.
  4358. *
  4359. *   INPUTS
  4360. *    day   - day of the date
  4361. *    month - month of the date
  4362. *    year  - year of the date
  4363. *
  4364. *   RESULT
  4365. *    week - This is the number of the week the specified date lies in.
  4366. *        If the first day in a new year is a Friday, Saturday or
  4367. *        Sunday, this would be the last week of the last year!
  4368. *        If the 29.12. is a Monday, the 30.12. is a Monday or a Tuesday,
  4369. *        the 31.12. is a Monday, Tuesday or a Wednesday this is the
  4370. *        first week of the next year!
  4371. *
  4372. *   EXAMPLE
  4373. *    ...
  4374. *    weeknr = JulianWeek(4,10,1582);
  4375. *    ...
  4376. *
  4377. *   NOTES
  4378. *    It is is better only to use this function for years from 0 to 1582!
  4379. *
  4380. *   BUGS
  4381. *    For years < 0 errors could occur.
  4382. *
  4383. *   SEE ALSO
  4384. *    GregorianWeek(),HeisWeek(),JulianWeekday(),JulianDayDiff()
  4385. *
  4386. *****************************************************************************
  4387. *
  4388. *
  4389. */
  4390.  
  4391.  {long days;
  4392.   Weekdays firstweekday;
  4393.  
  4394.    firstweekday = JulianWeekday(1,1,year);
  4395.    days = (JulianDayDiff(1,1,year,day,month,year) + (long)firstweekday -1) / 7;
  4396.    if (firstweekday > Thursday)
  4397.      {if (days == 0)
  4398.         days = JulianWeek(31,12,year-1);
  4399.       else
  4400.         if ((firstweekday == Sunday) && JulianLeapYear(year) && (month == 12) && (day == 31))
  4401.           days = 1;
  4402.       return((unsigned short)days);
  4403.      }
  4404.    else
  4405.      {if (!JulianDaySmaller(day,month,year,29,12,year))
  4406.         {firstweekday = JulianWeekday(day,12,year);
  4407.          switch (day)
  4408.            {case 31 : if (firstweekday == Wednesday)
  4409.                         days = 0;
  4410.             case 30 : if (firstweekday == Tuesday)
  4411.                         days = 0;
  4412.             case 29 : if (firstweekday == Monday)
  4413.                         days = 0;
  4414.                       break;
  4415.             default : ;
  4416.            }
  4417.         }
  4418.       return((unsigned short)(days +1));
  4419.      }
  4420.  }
  4421.  
  4422.  
  4423.  #ifdef __MakeLib
  4424.    unsigned short __saveds __asm GregorianWeek(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year)
  4425.  #else
  4426.    unsigned short GregorianWeek(const unsigned short day, const unsigned short month, const int year)
  4427.  #endif
  4428.  
  4429. /*
  4430. ******* Date/GregorianWeek **************************************************
  4431. *
  4432. *   NAME
  4433. *    GregorianWeek -- Gets the weeknumber of a specified date. (V33)
  4434. *
  4435. *   SYNOPSIS
  4436. *    weeknr = GregorianWeek(day,month,year);
  4437. *      d0            d0   d1   d2
  4438. *
  4439. *    unsigned short GregorianWeek(const unsigned short day,
  4440. *        const unsigned short month, const int year);
  4441. *
  4442. *   FUNCTION
  4443. *    GregorianWeek gets the weeknumber for a specified date.
  4444. *
  4445. *   INPUTS
  4446. *    day   - day of the date
  4447. *    month - month of the date
  4448. *    year  - year of the date
  4449. *
  4450. *   RESULT
  4451. *    week - This is the number of the week the specified date lies in.
  4452. *        If the first day in a new year is a Friday, Saturday or
  4453. *        Sunday, this would be the last week of the last year!
  4454. *        If the 29.12. is a Monday, the 30.12. is a Monday or a Tuesday,
  4455. *        the 31.12. is a Monday, Tuesday or a Wednesday this is the
  4456. *        first week of the next year!
  4457. *
  4458. *   EXAMPLE
  4459. *    ...
  4460. *    weeknr = GregorianWeek(4,10,1582);
  4461. *    ...
  4462. *
  4463. *   NOTES
  4464. *    It is better only to use this function for years from 0 to 3000!
  4465. *
  4466. *   BUGS
  4467. *    For years < 0 errors could occur.
  4468. *
  4469. *   SEE ALSO
  4470. *    JulianWeek(),HeisWeek(),GregorianWeekday(),GregorianDayDiff()
  4471. *
  4472. *****************************************************************************
  4473. *
  4474. *
  4475. */
  4476.  
  4477.  {long days;
  4478.   Weekdays firstweekday;
  4479.  
  4480.    firstweekday = GregorianWeekday(1,1,year);
  4481.    days = (GregorianDayDiff(1,1,year,day,month,year) + (long)firstweekday -1) / 7;
  4482.    if (firstweekday > Thursday)
  4483.      {if (days == 0)
  4484.         days = GregorianWeek(31,12,year-1);
  4485.       else
  4486.         if ((firstweekday == Sunday) && GregorianLeapYear(year) && (month == 12) && (day == 31))
  4487.           days = 1;
  4488.       return((unsigned short)days);
  4489.      }
  4490.    else
  4491.      {if (!GregorianDaySmaller(day,month,year,29,12,year))
  4492.         {firstweekday = GregorianWeekday(day,12,year);
  4493.          switch (day)
  4494.            {case 31 : if (firstweekday == Wednesday)
  4495.                         days = 0;
  4496.             case 30 : if (firstweekday == Tuesday)
  4497.                         days = 0;
  4498.             case 29 : if (firstweekday == Monday)
  4499.                         days = 0;
  4500.                       break;
  4501.             default : ;
  4502.            }
  4503.         }
  4504.       return((unsigned short)(days +1));
  4505.      }
  4506.  }
  4507.  
  4508.  
  4509.  #ifdef __MakeLib
  4510.    unsigned short __saveds __asm HeisWeek(register __d0 const unsigned short day, register __d1 const unsigned short month, register __d2 const int year)
  4511.  #else
  4512.    unsigned short HeisWeek(const unsigned short day, const unsigned short month, const int year)
  4513.  #endif
  4514.  
  4515. /*
  4516. ******* Date/HeisWeek *******************************************************
  4517. *
  4518. *   NAME
  4519. *    HeisWeek -- Gets the weeknumber of a specified date. (V33)
  4520. *
  4521. *   SYNOPSIS
  4522. *    weeknr = HeisWeek(day,month,year);
  4523. *      d0           d0  d1    d2
  4524. *
  4525. *    unsigned short HeisWeek(const unsigned short day,
  4526. *        const unsigned short month, const int year);
  4527. *
  4528. *   FUNCTION
  4529. *    HeisWeek gets the weeknumber for a specified date.
  4530. *
  4531. *   INPUTS
  4532. *    day   - day of the date
  4533. *    month - month of the date
  4534. *    year  - year of the date
  4535. *
  4536. *   RESULT
  4537. *    week - This is the number of the week the specified date lies in.
  4538. *        If the first day in a new year is a Friday, Saturday or
  4539. *        Sunday, this would be the last week of the last year!
  4540. *        If the 29.12. is a Monday, the 30.12. is a Monday or a Tuesday,
  4541. *        the 31.12. is a Monday, Tuesday or a Wednesday this is the
  4542. *        first week of the next year!
  4543. *
  4544. *   EXAMPLE
  4545. *    ...
  4546. *    weeknr = HeisWeek(4,10,1582);
  4547. *    ...
  4548. *
  4549. *   NOTES
  4550. *    It is better only to use this function for years from 0 to 8000!
  4551. *
  4552. *   BUGS
  4553. *    For years < 0 errors could occur.
  4554. *
  4555. *   SEE ALSO
  4556. *    JulianWeek(),GregorianWeek(),HeisWeekday(),HeisDayDiff()
  4557. *
  4558. *****************************************************************************
  4559. *
  4560. *
  4561. */
  4562.  
  4563.  {long days;
  4564.   Weekdays firstweekday;
  4565.  
  4566.    firstweekday = HeisWeekday(1,1,year);
  4567.    days = (HeisDayDiff(1,1,year,day,month,year) + (long)firstweekday -1) / 7;
  4568.    if (firstweekday > Thursday)
  4569.      {if (days == 0)
  4570.         days = HeisWeek(31,12,year-1);
  4571.       else
  4572.         if ((firstweekday == Sunday) && HeisLeapYear(year) && (month == 12) && (day == 31))
  4573.           days = 1;
  4574.       return((unsigned short)days);
  4575.      }
  4576.    else
  4577.      {if (!HeisDaySmaller(day,month,year,29,12,year))
  4578.         {firstweekday = HeisWeekday(day,12,year);
  4579.          switch (day)
  4580.            {case 31 : if (firstweekday == Wednesday)
  4581.                         days = 0;
  4582.             case 30 : if (firstweekday == Tuesday)
  4583.                         days = 0;
  4584.             case 29 : if (firstweekday == Monday)
  4585.                         days = 0;
  4586.                       break;
  4587.             default : ;
  4588.            }
  4589.         }
  4590.       return((unsigned short)(days +1));
  4591.      }
  4592.  }
  4593.  
  4594.  /* ----------------------------------------------------------------------- */
  4595.  
  4596.  #ifdef __SASC_650
  4597.    #ifdef __MakeLib
  4598.      int __saveds __UserLibInit(struct Library *libbase)
  4599.    #else
  4600.      void _STI_600__DateInit(void)
  4601.    #endif
  4602.  #else
  4603.    void _DateInit(void)
  4604.  #endif
  4605.  
  4606. /*
  4607. ******* Date/_DateInit ******************************************************
  4608. *
  4609. *   NAME
  4610. *    _DateInit -- Procedure to initialize this module! (V33)
  4611. *
  4612. *   SYNOPSIS
  4613. *    _DateInit();
  4614. *
  4615. *    void _DateInit(void);
  4616. *
  4617. *   FUNCTION
  4618. *    Initialize this module, like the modulebody in Modula-II or Oberon-2
  4619. *
  4620. *   INPUTS
  4621. *    None.
  4622. *
  4623. *   RESULT
  4624. *    None.
  4625. *
  4626. *   EXAMPLE
  4627. *    ...
  4628. *    _DateInit();
  4629. *    ...
  4630. *
  4631. *   NOTES
  4632. *    This function is only needed/available if you do not compile this
  4633. *    with a SAS C Compiler (using Autoinitialization!)
  4634. *    If you are not using SASC - don't forget to init this module with
  4635. *    this function - or you will get into trouble!!!
  4636. *
  4637. *   BUGS
  4638. *    unknown.
  4639. *
  4640. *   SEE ALSO
  4641. *
  4642. *
  4643. *****************************************************************************
  4644. *
  4645. *
  4646. */
  4647.  
  4648.  {/* Gregorian reform in Rom */
  4649.   BeforeGregorianDay = 4;
  4650.   BeforeGregorianMonth = 10;
  4651.   BeforeGregorianYear = 1582;
  4652.   AfterGregorianDay = 15;
  4653.   AfterGregorianMonth = 10;
  4654.   AfterGregorianYear = 1582;
  4655.   StartHeisDay = 1;
  4656.   StartHeisMonth = 1;
  4657.   StartHeisYear = 3200;
  4658.   /* Dates of Gregorian reform in
  4659.      Deutschland, Niederlande, Schweiz, Dänemark:
  4660.        18.02.1700-01.03.1700
  4661.      Großbritannien
  4662.        02.09.1752-14.09.1752
  4663.      Schweden
  4664.        17.02.1753-01.03.1753
  4665.      Rußland
  4666.        ? (oktober Revolution)
  4667.      Griechenland
  4668.        ??.??.1923-??.??.1923 */
  4669.   /* Bremen/Arbergen = 8° 55' 23" East, 53° 4' 8" North */
  4670.   #ifdef __MakeLib
  4671.     return(0);
  4672.   #endif
  4673.  }
  4674.  
  4675.  
  4676.  #ifdef __MakeLib
  4677.    void __saveds __UserLibCleanup(struct Library *libbase)
  4678.    {}
  4679.  #endif
  4680.